nmatrix-atlas 0.2.1 → 0.2.3

data/ext/nmatrix_atlas/math_atlas.cpp

@@ -368,11 +368,11 @@ static VALUE nm_atlas_cblas_nrm2(VALUE self, VALUE n, VALUE x, VALUE incx) {
 
   static void (*ttable[nm::NUM_DTYPES])(const int N, const void* X, const int incX, void* sum) = {
       NULL, NULL, NULL, NULL, NULL, // no help for integers
-      nm::math::atlas::cblas_nrm2<float32_t,float32_t>,
-      nm::math::atlas::cblas_nrm2<float64_t,float64_t>,
-      nm::math::atlas::cblas_nrm2<float32_t,nm::Complex64>,
-      nm::math::atlas::cblas_nrm2<float64_t,nm::Complex128>,
-      nm::math::atlas::cblas_nrm2<nm::RubyObject,nm::RubyObject>
+      nm::math::atlas::cblas_nrm2<float32_t>,
+      nm::math::atlas::cblas_nrm2<float64_t>,
+      nm::math::atlas::cblas_nrm2<nm::Complex64>,
+      nm::math::atlas::cblas_nrm2<nm::Complex128>,
+      nm::math::atlas::cblas_nrm2<nm::RubyObject>
   };
 
   nm::dtype_t dtype  = NM_DTYPE(x);
@@ -417,16 +417,16 @@ static VALUE nm_atlas_cblas_nrm2(VALUE self, VALUE n, VALUE x, VALUE incx) {
 static VALUE nm_atlas_cblas_asum(VALUE self, VALUE n, VALUE x, VALUE incx) {
 
   static void (*ttable[nm::NUM_DTYPES])(const int N, const void* X, const int incX, void* sum) = {
-      nm::math::atlas::cblas_asum<uint8_t,uint8_t>,
-      nm::math::atlas::cblas_asum<int8_t,int8_t>,
-      nm::math::atlas::cblas_asum<int16_t,int16_t>,
-      nm::math::atlas::cblas_asum<int32_t,int32_t>,
-      nm::math::atlas::cblas_asum<int64_t,int64_t>,
-      nm::math::atlas::cblas_asum<float32_t,float32_t>,
-      nm::math::atlas::cblas_asum<float64_t,float64_t>,
-      nm::math::atlas::cblas_asum<float32_t,nm::Complex64>,
-      nm::math::atlas::cblas_asum<float64_t,nm::Complex128>,
-      nm::math::atlas::cblas_asum<nm::RubyObject,nm::RubyObject>
+      nm::math::atlas::cblas_asum<uint8_t>,
+      nm::math::atlas::cblas_asum<int8_t>,
+      nm::math::atlas::cblas_asum<int16_t>,
+      nm::math::atlas::cblas_asum<int32_t>,
+      nm::math::atlas::cblas_asum<int64_t>,
+      nm::math::atlas::cblas_asum<float32_t>,
+      nm::math::atlas::cblas_asum<float64_t>,
+      nm::math::atlas::cblas_asum<nm::Complex64>,
+      nm::math::atlas::cblas_asum<nm::Complex128>,
+      nm::math::atlas::cblas_asum<nm::RubyObject>
   };
 
   nm::dtype_t dtype  = NM_DTYPE(x);

data/lib/nmatrix/atlas.rb

@@ -9,8 +9,8 @@
 #
 # == Copyright Information
 #
-# SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
-# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+# SciRuby is Copyright (c) 2010 - 2016, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2016, John Woods and the Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -27,7 +27,8 @@
 # nice ruby interfaces for ATLAS functions.
 #++
 
-require 'nmatrix/nmatrix.rb' #need to have nmatrix required first or else bad things will happen
+require 'nmatrix/nmatrix.rb'
+ #need to have nmatrix required first or else bad things will happen
 require_relative 'lapack_ext_common'
 
 NMatrix.register_lapack_extension("nmatrix-atlas")
@@ -57,26 +58,37 @@ class NMatrix
   module LAPACK
     class << self
       def posv(uplo, a, b)
-        raise(ShapeError, "a must be square") unless a.dim == 2 && a.shape[0] == a.shape[1]
-        raise(ShapeError, "number of rows of b must equal number of cols of a") unless a.shape[1] == b.shape[0]
-        raise(StorageTypeError, "only works with dense matrices") unless a.stype == :dense && b.stype == :dense
-        raise(DataTypeError, "only works for non-integer, non-object dtypes") if 
-          a.integer_dtype? || a.object_dtype? || b.integer_dtype? || b.object_dtype?
+        raise(ShapeError, "a must be square") unless a.dim == 2 \
+         && a.shape[0] == a.shape[1]
+
+        raise(ShapeError, "number of rows of b must equal number of cols of a") \
+         unless a.shape[1] == b.shape[0]
+
+        raise(StorageTypeError, "only works with dense matrices") \
+         unless a.stype == :dense && b.stype == :dense
+
+        raise(DataTypeError, "only works for non-integer, non-object dtypes") \
+         if  a.integer_dtype? || a.object_dtype? || \
+          b.integer_dtype? || b.object_dtype?
 
         x     = b.clone
         clone = a.clone
         n = a.shape[0]
         nrhs = b.shape[1]
         clapack_potrf(:row, uplo, n, clone, n)
-        # Must transpose b before and after: http://math-atlas.sourceforge.net/faq.html#RowSolve
+        # Must transpose b before and after:
+        #  http://math-atlas.sourceforge.net/faq.html#RowSolve
         x = x.transpose
         clapack_potrs(:row, uplo, n, nrhs, clone, n, x, n)
         x.transpose
       end
 
       def geev(matrix, which=:both)
-        raise(StorageTypeError, "LAPACK functions only work on dense matrices") unless matrix.dense?
-        raise(ShapeError, "eigenvalues can only be computed for square matrices") unless matrix.dim == 2 && matrix.shape[0] == matrix.shape[1]
+        raise(StorageTypeError, "LAPACK functions only work on dense matrices") \
+         unless matrix.dense?
+
+        raise(ShapeError, "eigenvalues can only be computed for square matrices") \
+         unless matrix.dim == 2 && matrix.shape[0] == matrix.shape[1]
 
         jobvl = (which == :both || which == :left) ? :t : false
         jobvr = (which == :both || which == :right) ? :t : false
@@ -84,8 +96,10 @@ class NMatrix
         n = matrix.shape[0]
 
         # Outputs
-        eigenvalues = NMatrix.new([n, 1], dtype: matrix.dtype) # For real dtypes this holds only the real part of the eigenvalues.
-        imag_eigenvalues = matrix.complex_dtype? ? nil : NMatrix.new([n, 1], dtype: matrix.dtype) # For complex dtypes, this is unused.
+        eigenvalues = NMatrix.new([n, 1], dtype: matrix.dtype)
+         # For real dtypes this holds only the real part of the eigenvalues.
+        imag_eigenvalues = matrix.complex_dtype? ? nil : NMatrix.new([n, 1], \
+         dtype: matrix.dtype) # For complex dtypes, this is unused.
         left_output      = jobvl ? matrix.clone_structure : nil
         right_output     = jobvr ? matrix.clone_structure : nil
 
@@ -121,19 +135,25 @@ class NMatrix
 
           if !complex_indices.empty?
             # For real dtypes, put the real and imaginary parts together
-            eigenvalues = eigenvalues + imag_eigenvalues*Complex(0.0,1.0)
-            left_output = left_output.cast(dtype: NMatrix.upcast(:complex64, matrix.dtype)) if left_output
-            right_output = right_output.cast(dtype: NMatrix.upcast(:complex64, matrix.dtype)) if right_output
+            eigenvalues = eigenvalues + imag_eigenvalues * \
+             Complex(0.0,1.0)
+            left_output = left_output.cast(dtype: \
+             NMatrix.upcast(:complex64, matrix.dtype)) if left_output
+            right_output = right_output.cast(dtype: NMatrix.upcast(:complex64, \
+             matrix.dtype)) if right_output
           end
 
           complex_indices.each_slice(2) do |i, _|
             if right_output
-              right_output[0...n,i] = right_output[0...n,i] + right_output[0...n,i+1]*Complex(0.0,1.0)
-              right_output[0...n,i+1] = right_output[0...n,i].complex_conjugate
+              right_output[0...n,i] = right_output[0...n,i] + \
+               right_output[0...n,i+1] * Complex(0.0,1.0)
+              right_output[0...n,i+1] = \
+               right_output[0...n,i].complex_conjugate
             end
 
             if left_output
-              left_output[0...n,i] = left_output[0...n,i] + left_output[0...n,i+1]*Complex(0.0,1.0)
+              left_output[0...n,i] = left_output[0...n,i] + \
+               left_output[0...n,i+1] * Complex(0.0,1.0)
               left_output[0...n,i+1] = left_output[0...n,i].complex_conjugate
             end
           end
@@ -157,15 +177,18 @@ class NMatrix
         # This is a pure LAPACK function so it expects column-major functions.
         # So we need to transpose the input as well as the output.
         matrix = matrix.transpose
-        NMatrix::LAPACK::lapack_gesvd(:a, :a, m, n, matrix, m, result[1], result[0], m, result[2], n, workspace_size)
+        NMatrix::LAPACK::lapack_gesvd(:a, :a, m, n, matrix, \
+         m, result[1], result[0], m, result[2], n, workspace_size)
         result[0] = result[0].transpose
         result[2] = result[2].transpose
         result
       end
 
       def gesdd(matrix, workspace_size=nil)
-        min_workspace_size = matrix.shape.min * (6 + 4 * matrix.shape.min) + matrix.shape.max
-        workspace_size = min_workspace_size if workspace_size.nil? || workspace_size < min_workspace_size
+        min_workspace_size = matrix.shape.min * \
+         (6 + 4 * matrix.shape.min) + matrix.shape.max
+        workspace_size = min_workspace_size if \
+         workspace_size.nil? || workspace_size < min_workspace_size
 
         result = alloc_svd_result(matrix)
 
@@ -175,7 +198,8 @@ class NMatrix
         # This is a pure LAPACK function so it expects column-major functions.
         # So we need to transpose the input as well as the output.
         matrix = matrix.transpose
-        NMatrix::LAPACK::lapack_gesdd(:a, m, n, matrix, m, result[1], result[0], m, result[2], n, workspace_size)
+        NMatrix::LAPACK::lapack_gesdd(:a, m, n, matrix, m, result[1], \
+         result[0], m, result[2], n, workspace_size)
         result[0] = result[0].transpose
         result[2] = result[2].transpose
         result
@@ -184,9 +208,14 @@ class NMatrix
   end
 
   def invert!
-    raise(StorageTypeError, "invert only works on dense matrices currently") unless self.dense?
-    raise(ShapeError, "Cannot invert non-square matrix") unless shape[0] == shape[1]
-    raise(DataTypeError, "Cannot invert an integer matrix in-place") if self.integer_dtype?
+    raise(StorageTypeError, "invert only works on dense matrices currently") \
+     unless self.dense?
+
+    raise(ShapeError, "Cannot invert non-square matrix") \
+     unless shape[0] == shape[1]
+
+    raise(DataTypeError, "Cannot invert an integer matrix in-place") \
+     if self.integer_dtype?
 
     # Even though we are using the ATLAS plugin, we still might be missing
     # CLAPACK (and thus clapack_getri) if we are on OS X.
@@ -205,8 +234,10 @@ class NMatrix
   end
 
   def potrf!(which)
-    raise(StorageTypeError, "ATLAS functions only work on dense matrices") unless self.dense?
-    raise(ShapeError, "Cholesky decomposition only valid for square matrices") unless self.dim == 2 && self.shape[0] == self.shape[1]
+    raise(StorageTypeError, "ATLAS functions only work on dense matrices") \
+     unless self.dense?
+    raise(ShapeError, "Cholesky decomposition only valid for square matrices") \
+     unless self.dim == 2 && self.shape[0] == self.shape[1]
 
     NMatrix::LAPACK::clapack_potrf(:row, which, self.shape[0], self, self.shape[1])
   end

data/spec/00_nmatrix_spec.rb

@@ -424,6 +424,13 @@ describe 'NMatrix' do
       expect(n.reshape!([8,2]).eql?(n)).to eq(true) # because n itself changes
     end
 
+    it "should do the reshape operation in place, changing dimension" do
+      n = NMatrix.seq(4)
+      a = n.reshape!([4,2,2])
+      expect(n).to eq(NMatrix.seq([4,2,2]))
+      expect(a).to eq(NMatrix.seq([4,2,2]))
+    end
+
     it "reshape and reshape! must produce same result" do
       n = NMatrix.seq(4)+1
       a = NMatrix.seq(4)+1
@@ -432,7 +439,7 @@ describe 'NMatrix' do
 
     it "should prevent a resize in place" do
       n = NMatrix.seq(4)+1
-      expect { n.reshape([5,2]) }.to raise_error(ArgumentError)
+      expect { n.reshape!([5,2]) }.to raise_error(ArgumentError)
     end
   end
 
@@ -534,6 +541,26 @@ describe 'NMatrix' do
       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
+
+    it "should work on matrices with different size along concat dim" do
+      n = N[[1, 2, 3],
+            [4, 5, 6]]
+      m = N[[7],
+            [8]]
+
+      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
+
+    it "should work on matrices with different size along concat dim" do
+      n = N[[1, 2, 3],
+            [4, 5, 6]]
+
+      m = N[[7, 8, 9]]
+
+      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
   end
 
   context "#[]" do
@@ -631,6 +658,23 @@ describe 'NMatrix' do
     end
   end
 
+  context "#last" do
+    it "returns the last element of a 1-dimensional NMatrix" do
+      n = NMatrix.new([1,4], [1,2,3,4])
+      expect(n.last).to eq(4)
+    end
+
+    it "returns the last element of a 2-dimensional NMatrix" do
+      n = NMatrix.new([2,2], [4,8,12,16])
+      expect(n.last).to eq(16)
+    end
+
+    it "returns the last element of a 3-dimensional NMatrix" do
+      n = NMatrix.new([2,2,2], [1,2,3,4,5,6,7,8])
+      expect(n.last).to eq(8)
+    end
+  end
+
   context "#diagonal" do
     ALL_DTYPES.each do |dtype|
       before do 
@@ -682,6 +726,11 @@ describe 'NMatrix' 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
+
+    it "preserves dtype" do
+      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
   end
 
   context "#meshgrid" do

data/spec/02_slice_spec.rb

@@ -127,9 +127,9 @@ describe "Slice operation" do
       it "should have #is_ref? method" do
         a = stype_matrix[0..1, 0..1]
         b = stype_matrix.slice(0..1, 0..1)
-        expect(stype_matrix.is_ref?).to be_false
-        expect(a.is_ref?).to be_true
-        expect(b.is_ref?).to be_false
+        expect(stype_matrix.is_ref?).to be false
+        expect(a.is_ref?).to be true
+        expect(b.is_ref?).to be false
       end
 
       it "reference should compare with non-reference" do
@@ -141,7 +141,7 @@ describe "Slice operation" do
       context "with copying" do
         it 'should return an NMatrix' do
           n = stype_matrix.slice(0..1,0..1)
-          expect(nm_eql(n, NMatrix.new([2,2], [0,1,3,4], dtype: :int32))).to be_true
+          expect(nm_eql(n, NMatrix.new([2,2], [0,1,3,4], dtype: :int32))).to be true
         end
 
         it 'should return a copy of 2x2 matrix to self elements' do
@@ -183,19 +183,19 @@ describe "Slice operation" do
 
         [:dense, :list, :yale].each do |cast_type|
           it "should cast copied slice from #{stype.upcase} to #{cast_type.upcase}" do
-            expect(nm_eql(stype_matrix.slice(1..2, 1..2).cast(cast_type, :int32), stype_matrix.slice(1..2,1..2))).to be_true
-            expect(nm_eql(stype_matrix.slice(0..1, 1..2).cast(cast_type, :int32), stype_matrix.slice(0..1,1..2))).to be_true
-            expect(nm_eql(stype_matrix.slice(1..2, 0..1).cast(cast_type, :int32), stype_matrix.slice(1..2,0..1))).to be_true
-            expect(nm_eql(stype_matrix.slice(0..1, 0..1).cast(cast_type, :int32), stype_matrix.slice(0..1,0..1))).to be_true
+            expect(nm_eql(stype_matrix.slice(1..2, 1..2).cast(cast_type, :int32), stype_matrix.slice(1..2,1..2))).to be true
+            expect(nm_eql(stype_matrix.slice(0..1, 1..2).cast(cast_type, :int32), stype_matrix.slice(0..1,1..2))).to be true
+            expect(nm_eql(stype_matrix.slice(1..2, 0..1).cast(cast_type, :int32), stype_matrix.slice(1..2,0..1))).to be true
+            expect(nm_eql(stype_matrix.slice(0..1, 0..1).cast(cast_type, :int32), stype_matrix.slice(0..1,0..1))).to be true
 
             # Non square
-            expect(nm_eql(stype_matrix.slice(0..2, 1..2).cast(cast_type, :int32), stype_matrix.slice(0..2,1..2))).to be_true
+            expect(nm_eql(stype_matrix.slice(0..2, 1..2).cast(cast_type, :int32), stype_matrix.slice(0..2,1..2))).to be true
             #require 'pry'
             #binding.pry if cast_type == :yale
-            expect(nm_eql(stype_matrix.slice(1..2, 0..2).cast(cast_type, :int32), stype_matrix.slice(1..2,0..2))).to be_true
+            expect(nm_eql(stype_matrix.slice(1..2, 0..2).cast(cast_type, :int32), stype_matrix.slice(1..2,0..2))).to be true
 
             # Full
-            expect(nm_eql(stype_matrix.slice(0..2, 0..2).cast(cast_type, :int32), stype_matrix)).to be_true
+            expect(nm_eql(stype_matrix.slice(0..2, 0..2).cast(cast_type, :int32), stype_matrix)).to be true
           end
         end
       end
@@ -214,7 +214,7 @@ describe "Slice operation" do
       context "by reference" do
         it 'should return an NMatrix' do
           n = stype_matrix[0..1,0..1]
-          expect(nm_eql(n, NMatrix.new([2,2], [0,1,3,4], dtype: :int32))).to be_true
+          expect(nm_eql(n, NMatrix.new([2,2], [0,1,3,4], dtype: :int32))).to be true
         end
 
         it 'should return a 2x2 matrix with refs to self elements' do
@@ -246,7 +246,7 @@ describe "Slice operation" do
 
         it 'should slice again' do
           n = stype_matrix[1..2, 1..2]
-          expect(nm_eql(n[1,0..1], NVector.new(2, [7,8], dtype: :int32).transpose)).to be_true
+          expect(nm_eql(n[1,0..1], NVector.new(2, [7,8], dtype: :int32).transpose)).to be true
         end
 
         it 'should be correct slice for range 0..2 and 0...3' do
@@ -320,7 +320,7 @@ describe "Slice operation" do
             end
 
             it "compares slices to scalars" do
-              (stype_matrix[1, 0..2] > 2).each { |e| expect(e != 0).to be_true }
+              (stype_matrix[1, 0..2] > 2).each { |e| expect(e != 0).to be true }
             end
 
             it "iterates only over elements in the slice" do
@@ -367,20 +367,20 @@ describe "Slice operation" do
 
         [:dense, :list, :yale].each do |cast_type|
           it "should cast a square reference-slice from #{stype.upcase} to #{cast_type.upcase}" do
-            expect(nm_eql(stype_matrix[1..2, 1..2].cast(cast_type), stype_matrix[1..2,1..2])).to be_true
-            expect(nm_eql(stype_matrix[0..1, 1..2].cast(cast_type), stype_matrix[0..1,1..2])).to be_true
-            expect(nm_eql(stype_matrix[1..2, 0..1].cast(cast_type), stype_matrix[1..2,0..1])).to be_true
-            expect(nm_eql(stype_matrix[0..1, 0..1].cast(cast_type), stype_matrix[0..1,0..1])).to be_true
+            expect(nm_eql(stype_matrix[1..2, 1..2].cast(cast_type), stype_matrix[1..2,1..2])).to be true
+            expect(nm_eql(stype_matrix[0..1, 1..2].cast(cast_type), stype_matrix[0..1,1..2])).to be true
+            expect(nm_eql(stype_matrix[1..2, 0..1].cast(cast_type), stype_matrix[1..2,0..1])).to be true
+            expect(nm_eql(stype_matrix[0..1, 0..1].cast(cast_type), stype_matrix[0..1,0..1])).to be true
           end
 
           it "should cast a rectangular reference-slice from #{stype.upcase} to #{cast_type.upcase}" do
             # Non square
-            expect(nm_eql(stype_matrix[0..2, 1..2].cast(cast_type), stype_matrix[0..2,1..2])).to be_true # FIXME: memory problem.
-            expect(nm_eql(stype_matrix[1..2, 0..2].cast(cast_type), stype_matrix[1..2,0..2])).to be_true # this one is fine
+            expect(nm_eql(stype_matrix[0..2, 1..2].cast(cast_type), stype_matrix[0..2,1..2])).to be true # FIXME: memory problem.
+            expect(nm_eql(stype_matrix[1..2, 0..2].cast(cast_type), stype_matrix[1..2,0..2])).to be true # this one is fine
           end
 
           it "should cast a square full-matrix reference-slice from #{stype.upcase} to #{cast_type.upcase}" do
-            expect(nm_eql(stype_matrix[0..2, 0..2].cast(cast_type), stype_matrix)).to be_true
+            expect(nm_eql(stype_matrix[0..2, 0..2].cast(cast_type), stype_matrix)).to be true
           end
         end
       end

data/spec/blas_spec.rb

@@ -69,6 +69,18 @@ describe NMatrix::BLAS do
         expect(b[0]).to eq(-15.0/2)
         expect(b[1]).to eq(5)
         expect(b[2]).to eq(-13)
+        
+        NMatrix::BLAS::cblas_trsm(:row, :left, :lower, :transpose, :nounit, 3, 1, 1.0, a, 3, b, 1)
+
+        expect(b[0]).to eq(307.0/8)
+        expect(b[1]).to eq(57.0/2)
+        expect(b[2]).to eq(26.0)
+        
+        NMatrix::BLAS::cblas_trsm(:row, :left, :upper, :transpose, :unit, 3, 1, 1.0, a, 3, b, 1)
+
+        expect(b[0]).to eq(307.0/8)
+        expect(b[1]).to eq(763.0/16)
+        expect(b[2]).to eq(4269.0/64)        
       end
 
       # trmm multiplies two matrices, where one of the two is required to be
@@ -174,9 +186,17 @@ describe NMatrix::BLAS do
 
       it "exposes nrm2" do
         pending("broken for :object") if dtype == :object
-        pending("Temporarily disable because the internal implementation of nrm2 is broken -WL 2015-05-17") if dtype == :complex64 || dtype == :complex128
 
-        x = NMatrix.new([4,1], [2,-4,3,5], dtype: dtype)
+        if dtype =~ /complex/
+          x = NMatrix.new([3,1], [Complex(1,2),Complex(3,4),Complex(0,6)], dtype: dtype)
+          y = NMatrix.new([3,1], [Complex(0,0),Complex(0,0),Complex(0,0)], dtype: dtype)
+          nrm2 = 8.12403840463596
+        else
+          x = NMatrix.new([4,1], [2,-4,3,5], dtype: dtype)
+          y = NMatrix.new([3,1], [0,0,0], dtype: dtype)
+          nrm2 = 5.385164807134504
+        end
+        
         err = case dtype
                 when :float32, :complex64
                   1e-6
@@ -185,7 +205,9 @@ describe NMatrix::BLAS do
                 else
                   1e-14
               end
-        expect(NMatrix::BLAS.nrm2(x, 1, 3)).to be_within(err).of(5.385164807134504)
+
+        expect(NMatrix::BLAS.nrm2(x, 1, 3)).to be_within(err).of(nrm2)
+        expect(NMatrix::BLAS.nrm2(y, 1, 3)).to be_within(err).of(0)
       end
 
     end