nmatrix-fftw 0.2.1 → 0.2.3

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

data/spec/math_spec.rb

@@ -285,6 +285,152 @@ describe "math" do
     end
   end
 
+  NON_INTEGER_DTYPES.each do |dtype|
+    next if dtype == :object
+    context dtype do
+      
+      it "calculates QR decomposition using factorize_qr for a square matrix" do
+
+        a = NMatrix.new(3, [12.0, -51.0,   4.0, 
+                             6.0, 167.0, -68.0, 
+                            -4.0,  24.0, -41.0] , dtype: dtype)
+        
+        q_solution = NMatrix.new([3,3], Q_SOLUTION_ARRAY_2, dtype: dtype)
+
+        r_solution = NMatrix.new([3,3], [-14.0, -21.0, 14, 
+                                           0.0,  -175, 70, 
+                                           0.0, 0.0,  -35] , dtype: dtype)
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-4
+                when :float64, :complex128
+                  1e-13
+              end
+        
+        begin
+          q,r = a.factorize_qr
+          
+          expect(q).to be_within(err).of(q_solution)
+          expect(r).to be_within(err).of(r_solution)
+        
+        rescue NotImplementedError
+          pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+        end
+      end
+
+      it "calculates QR decomposition using factorize_qr for a tall and narrow rectangular matrix" do
+
+        a = NMatrix.new([4,2], [34.0, 21.0, 
+                                23.0, 53.0, 
+                                26.0, 346.0, 
+                                23.0, 121.0] , dtype: dtype)
+        
+        q_solution = NMatrix.new([4,4], Q_SOLUTION_ARRAY_1, dtype: dtype)
+
+        r_solution = NMatrix.new([4,2], [-53.75872022286244, -255.06559574252242, 
+                                                        0.0,  269.34836526051555, 
+                                                        0.0,                 0.0, 
+                                                        0.0,                 0.0] , dtype: dtype)
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-4
+                when :float64, :complex128
+                  1e-13
+              end
+        
+        begin
+          q,r = a.factorize_qr
+          
+          expect(q).to be_within(err).of(q_solution)
+          expect(r).to be_within(err).of(r_solution)
+        
+        rescue NotImplementedError
+          pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+        end
+      end
+
+      it "calculates QR decomposition using factorize_qr for a short and wide rectangular matrix" do
+          
+        a = NMatrix.new([3,4], [123,31,57,81,92,14,17,36,42,34,11,28], dtype: dtype)
+        
+        q_solution = NMatrix.new([3,3], Q_SOLUTION_ARRAY_3, dtype: dtype)
+
+        r_solution = NMatrix.new([3,4], R_SOLUTION_ARRAY, dtype: dtype)
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-4
+                when :float64, :complex128
+                  1e-13
+              end
+        
+        begin
+          q,r = a.factorize_qr
+          
+          expect(q).to be_within(err).of(q_solution)
+          expect(r).to be_within(err).of(r_solution)
+        
+        rescue NotImplementedError
+          pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+        end
+      end
+      
+      it "calculates QR decomposition such that A - QR ~ 0" do
+
+        a = NMatrix.new([3,3], [ 9.0,  0.0, 26.0, 
+                                12.0,  0.0, -7.0,  
+                                 0.0,  4.0,  0.0] , dtype: dtype)
+        
+        err = case dtype
+                when :float32, :complex64
+                  1e-4
+                when :float64, :complex128
+                  1e-13
+              end
+        
+        begin
+          q,r = a.factorize_qr
+          a_expected = q.dot(r)  
+          
+          expect(a_expected).to be_within(err).of(a)
+               
+        rescue NotImplementedError
+          pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+        end
+      end
+
+
+      it "calculates the orthogonal matrix Q in QR decomposition" do
+
+        a = N.new([2,2], [34.0, 21, 23, 53] , dtype: dtype)
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-4
+                when :float64, :complex128
+                  1e-13
+              end
+        
+        begin
+          q,r = a.factorize_qr
+          
+          #Q is orthogonal if Q x Q.transpose = I
+          product = q.dot(q.transpose)
+
+          expect(product[0,0]).to be_within(err).of(1)
+          expect(product[1,0]).to be_within(err).of(0)
+          expect(product[0,1]).to be_within(err).of(0)
+          expect(product[1,1]).to be_within(err).of(1)
+
+        rescue NotImplementedError
+          pending "Suppressing a NotImplementedError when the lapacke plugin is not available"
+        end
+      end
+    end
+  end
+
   ALL_DTYPES.each do |dtype|
     next if dtype == :byte #doesn't work for unsigned types
     next if dtype == :object
@@ -332,6 +478,49 @@ describe "math" do
     end
   end
 
+  ALL_DTYPES.each do |dtype|
+    next if dtype == :byte #doesn't work for unsigned types
+    next if dtype == :object
+
+    context dtype do
+      err = case dtype
+              when :float32, :complex64
+                1e-4
+              else #integer matrices will return :float64
+                1e-13
+            end
+
+      it "should correctly find adjugate a matrix in place (bang)" do
+        a = NMatrix.new(:dense, 2, [2, 3, 3, 5], dtype)
+        b = NMatrix.new(:dense, 2, [5, -3, -3, 2], dtype)
+
+        if a.integer_dtype?
+          expect{a.adjugate!}.to raise_error(DataTypeError)
+        else
+          #should return adjugate as well as modifying a
+          r = a.adjugate!
+          expect(a).to be_within(err).of(b)
+          expect(r).to be_within(err).of(b)
+        end
+      end
+
+
+      it "should correctly find adjugate of a matrix out-of-place" do
+        a = NMatrix.new(:dense, 3, [-3, 2, -5, -1, 0, -2, 3, -4, 1], dtype)
+
+        if a.integer_dtype?
+          b = NMatrix.new(:dense, 3, [-8, 18, -4, -5, 12, -1, 4, -6, 2], :float64)
+        else
+          b = NMatrix.new(:dense, 3, [-8, 18, -4, -5, 12, -1, 4, -6, 2], dtype)
+        end
+
+        expect(a.adjoint).to be_within(err).of(b)
+        expect(a.adjugate).to be_within(err).of(b)
+      end
+
+    end
+  end
+
   # TODO: Get it working with ROBJ too
   [:byte,:int8,:int16,:int32,:int64,:float32,:float64].each do |left_dtype|
     [:byte,:int8,:int16,:int32,:int64,:float32,:float64].each do |right_dtype|
@@ -702,7 +891,7 @@ describe "math" do
                                                      360, 96, 51, -14,
                                                      448,-231,-24,-87,
                                                    -1168, 595,234, 523], 
-                                                   dtype: answer_dtype, 
+                                                   dtype: answer_dtype,
                                                    stype: stype))
         end
 
@@ -757,7 +946,6 @@ describe "math" do
 
   context "determinants" do
     ALL_DTYPES.each do |dtype|
-      next if dtype == :object
       context dtype do
         before do
           @a = NMatrix.new([2,2], [1,2,
@@ -779,13 +967,19 @@ describe "math" do
                 end
         end
         it "computes the determinant of 2x2 matrix" do
-          expect(@a.det).to be_within(@err).of(-2)
+          if dtype != :object
+            expect(@a.det).to be_within(@err).of(-2)
+          end
         end
         it "computes the determinant of 3x3 matrix" do
-          expect(@b.det).to be_within(@err).of(-8)
+          if dtype != :object
+            expect(@b.det).to be_within(@err).of(-8)
+          end
         end
         it "computes the determinant of 4x4 matrix" do
-          expect(@c.det).to be_within(@err).of(-18)
+          if dtype != :object
+            expect(@c.det).to be_within(@err).of(-18)
+          end
         end
         it "computes the exact determinant of 2x2 matrix" do
           if dtype == :byte
@@ -804,4 +998,38 @@ describe "math" do
       end
     end
   end
+
+  context "#scale and #scale!" do
+    [:dense,:list,:yale].each do |stype|
+      ALL_DTYPES.each do |dtype|
+        next if dtype == :object
+        context "for #{dtype}" do
+          before do
+            @m = NMatrix.new([3, 3], [0, 1, 2,
+                                      3, 4, 5,
+                                      6, 7, 8], stype: stype, dtype: dtype)
+          end
+          it "scales the matrix by a given factor and return the result" do
+            if integer_dtype? dtype
+              expect{@m.scale 2.0}.to raise_error(DataTypeError)
+            else
+              expect(@m.scale 2.0).to eq(NMatrix.new([3, 3], [0,  2,  4,
+                                                             6,  8,  10,
+                                                             12, 14, 16], stype: stype, dtype: dtype))
+            end
+          end
+          it "scales the matrix in place by a given factor" do
+              if dtype == :int8
+                expect{@m.scale! 2}.to raise_error(DataTypeError)
+              else
+                @m.scale! 2
+                expect(@m).to eq(NMatrix.new([3, 3], [0,  2,  4,
+                                                      6,  8,  10,
+                                                      12, 14, 16], stype: stype, dtype: dtype))
+              end
+          end
+        end
+      end
+    end
+  end
 end

data/spec/shortcuts_spec.rb

@@ -50,10 +50,45 @@ describe NMatrix do
     expect(m).to eq identity3
   end
 
+  it "hilbert() creates an hilbert matrix" do
+    m = NMatrix.hilbert(8)
+    expect(m[4, 0]).to be_within(0.000001).of(0.2)
+    expect(m[4, 1]).to be_within(0.000001).of(0.16666666666666666)
+    expect(m[4, 2]).to be_within(0.000001).of(0.14285714285714285)
+    expect(m[4, 3]).to be_within(0.000001).of(0.125)
+
+    m = NMatrix.hilbert(3)
+    hilbert3 = NMatrix.new([3, 3], [1.0, 0.5, 0.3333333333333333,\
+     0.5, 0.3333333333333333, 0.25, 0.3333333333333333, 0.25, 0.2])
+    expect(m).to eq hilbert3
+    0.upto(2) do |i|
+      0.upto(2) do |j|
+        expect(m[i, j]).to be_within(0.000001).of(hilbert3[i,j])
+      end
+    end
+  end
+
+  it "inv_hilbert() creates an inverse hilbert matrix" do
+    m = NMatrix.inv_hilbert(6)
+    inv_hilbert6 = [3360.0,  -88200.0,   564480.0, -1411200.0]
+    expect(m[2,0]).to be_within(0.000001).of(inv_hilbert6[0])
+    expect(m[2,1]).to be_within(0.000001).of(inv_hilbert6[1])
+    expect(m[2,2]).to be_within(0.000001).of(inv_hilbert6[2])
+    expect(m[2,3]).to be_within(0.000001).of(inv_hilbert6[3])
+
+    m = NMatrix.inv_hilbert(3)
+    inv_hilbert3 = NMatrix.new([3, 3], [  9.0,  -36.0,   30.0, -36.0,  192.0, -180.0, 30.0, -180.0,  180.0] )
+    0.upto(2) do |i|
+      0.upto(2) do |j|
+        expect(m[i, j]).to be_within(0.000001).of(inv_hilbert3[i,j])
+      end
+    end
+  end
+
   it "diag() creates a matrix with pre-supplied diagonal" do
     arr = [1,2,3,4]
     m = NMatrix.diag(arr)
-    expect(m.is_a?(NMatrix)).to be_true
+    expect(m.is_a?(NMatrix)).to be true
   end
 
   it "diagonals() contains the seeded values on the diagonal" do
@@ -123,6 +158,112 @@ describe NMatrix do
       expect { NMatrix.random("not an array or integer") }.to raise_error
     end
   end
+  
+  context "::magic" do
+    
+    ALL_DTYPES.each do |dtype|
+      context dtype do
+        it "creates a matrix with numbers from 1 to n^n(n squared)" do
+          a = NMatrix.magic(3, dtype: dtype)
+          magic3 = NMatrix.new([3,3], [4, 9, 2, 3, 5, 7, 8, 1, 6], dtype: dtype)	
+          expect(a).to eq magic3
+      
+          b = NMatrix.magic(4, dtype: dtype)
+          magic4 = NMatrix.new([4,4], [1, 15, 14,  4, 12,  6,  7, 9, 8, 10, 11, 5, 13, 3, 2, 16], dtype: dtype)
+          expect(b).to eq magic4
+      
+          c = NMatrix.magic(6, dtype: dtype)
+          magic6 = NMatrix.new([6,6], [31, 9, 2, 22, 27, 20, 3, 32, 7, 21, 23, 25, 35, 1, 6, 26, 19, 24, 4, 36, 29, 13, 18, 11, 30, 5, 34, 12, 14, 16, 8, 28, 33, 17, 10, 15], dtype: dtype)
+          expect(c).to eq magic6  
+        end
+      end
+    end
+    
+    it "shape of two is not allowed" do
+      expect { NMatrix.magic(2) }.to raise_error(ArgumentError)
+    end
+    
+    it "Only accepts an integer as dimension" do 
+      expect { NMatrix.magic(3.0) }.to raise_error(ArgumentError)
+    end
+  end
+  
+  context "::linspace" do
+    it "creates a row vector when given only one shape parameter" do
+      v = NMatrix.linspace(1, 10, 4)
+      #Expect a row vector only
+      expect(v.shape.length).to eq(1)
+      
+      ans = [1.0,4.0,7.0,10.0]
+
+      expect(v[0]).to be_within(0.000001).of(ans[0])
+      expect(v[1]).to be_within(0.000001).of(ans[1])
+      expect(v[2]).to be_within(0.000001).of(ans[2])
+      expect(v[3]).to be_within(0.000001).of(ans[3])
+    end
+    
+    it "creates a matrix of input shape with each entry linearly spaced in row major order" do
+      v = NMatrix.linspace(1, Math::PI, [2,2])
+      expect(v.dtype).to eq(:float64)
+
+      ans = [1.0, 1.7138642072677612, 2.4277284145355225, 3.1415927410125732]
+      
+      expect(v[0,0]).to be_within(0.000001).of(ans[0])
+      expect(v[0,1]).to be_within(0.000001).of(ans[1])
+      expect(v[1,0]).to be_within(0.000001).of(ans[2])
+      expect(v[1,1]).to be_within(0.000001).of(ans[3])
+    end
+  end
+
+  context "::logspace" do
+    it "creates a logarithmically spaced vector" do
+      v = NMatrix.logspace(1, 2, 10)
+      
+      expect(v.shape.length).to eq(1)
+      
+      #Unit test taken from Matlab R2015b output of logspace(1,2,10)
+      ans = [10.0000, 12.9155, 16.6810, 21.5443, 27.8256, 35.9381, 46.4159, 59.9484, 77.4264, 100.0000]
+      
+      expect(v[0].round(4)).to be_within(0.000001).of(ans[0])
+      expect(v[1].round(4)).to be_within(0.000001).of(ans[1])
+      expect(v[2].round(4)).to be_within(0.000001).of(ans[2])
+      expect(v[3].round(4)).to be_within(0.000001).of(ans[3])
+      expect(v[4].round(4)).to be_within(0.000001).of(ans[4])
+      expect(v[5].round(4)).to be_within(0.000001).of(ans[5])
+      expect(v[6].round(4)).to be_within(0.000001).of(ans[6])
+      expect(v[7].round(4)).to be_within(0.000001).of(ans[7])
+      expect(v[8].round(4)).to be_within(0.000001).of(ans[8])
+      expect(v[9].round(4)).to be_within(0.000001).of(ans[9])
+    end
+    
+    it "creates a logarithmically spaced vector bounded by Math::PI if :pi is pre-supplied" do
+      v = NMatrix.logspace(1, :pi, 7)
+                 
+      #Unit test taken from Matlab R2015b output of logspace(1,pi,10)
+      ans = [10.0000, 8.2450, 6.7980, 5.6050, 4.6213, 3.8103, 3.1416]
+      
+      expect(v[0].round(4)).to be_within(0.000001).of(ans[0])
+      expect(v[1].round(4)).to be_within(0.000001).of(ans[1])
+      expect(v[2].round(4)).to be_within(0.000001).of(ans[2])
+      expect(v[3].round(4)).to be_within(0.000001).of(ans[3])
+      expect(v[4].round(4)).to be_within(0.000001).of(ans[4])
+      expect(v[5].round(4)).to be_within(0.000001).of(ans[5])
+      expect(v[6].round(4)).to be_within(0.000001).of(ans[6])
+    end    
+
+    it "creates a matrix of input shape with each entry logarithmically spaced in row major order" do
+      v = NMatrix.logspace(1, 2, [3,2])
+      
+      ans = [10.0, 15.8489, 25.1189, 39.8107, 63.0957, 100.0]
+      
+      expect(v[0,0].round(4)).to be_within(0.000001).of(ans[0])
+      expect(v[0,1].round(4)).to be_within(0.000001).of(ans[1])
+      expect(v[1,0].round(4)).to be_within(0.000001).of(ans[2])
+      expect(v[1,1].round(4)).to be_within(0.000001).of(ans[3])
+      expect(v[2,0].round(4)).to be_within(0.000001).of(ans[4])
+      expect(v[2,1].round(4)).to be_within(0.000001).of(ans[5])
+    end
+  end
 
   it "seq() creates a matrix of integers, sequentially" do
     m = NMatrix.seq(2) # 2x2 matrix.
@@ -136,7 +277,6 @@ describe NMatrix do
     end
   end
 
-
   it "indgen() creates a matrix of integers as well as seq()" do
     m = NMatrix.indgen(2) # 2x2 matrix.
     value = 0
@@ -189,19 +329,19 @@ describe NMatrix do
   it "column() returns a NMatrix" do
     m = NMatrix.random(3)
 
-    expect(m.column(2).is_a?(NMatrix)).to be_true
+    expect(m.column(2).is_a?(NMatrix)).to be true
   end
 
   it "row() returns a NMatrix" do
     m = NMatrix.random(3)
 
-    expect(m.row(2).is_a?(NMatrix)).to be_true
+    expect(m.row(2).is_a?(NMatrix)).to be true
   end
 
   it "diagonals() creates an NMatrix" do
     arr = [1,2,3,4]
     m = NMatrix.diagonals(arr)
-    expect(m.is_a?(NMatrix)).to be_true
+    expect(m.is_a?(NMatrix)).to be true
   end
 
   it "diagonals() contains the seeded values on the diagonal" do