nmatrix 0.1.0.rc3 → 0.1.0.rc4

data/spec/blas_spec.rb

@@ -25,13 +25,28 @@
 # Tests for properly exposed BLAS functions.
 #
 
-# Can we use require_relative here instead?
-require File.join(File.dirname(__FILE__), "spec_helper.rb")
+require 'spec_helper'
 
 describe NMatrix::BLAS do
-  #after :each do
-  #  GC.start
-  #end
+  [:byte, :int8, :int16, :int32, :int64,
+   :float32, :float64, :complex64, :complex128,
+   :rational32, :rational64, :rational128,
+   :object
+  ].each do |dtype|
+    context dtype do
+      it "exposes cblas_scal" do
+        x = NMatrix.new([3, 1], [1, 2, 3], dtype: dtype)
+        NMatrix::BLAS.cblas_scal(3, 2, x, 1)
+        expect(x).to eq(NMatrix.new([3, 1], [2, 4, 6], dtype: dtype))
+      end
+
+      it "exposes cblas_imax" do
+        u = NMatrix.new([3,1], [1, 4, 3], dtype: dtype)
+        index = NMatrix::BLAS.cblas_imax(3, u, 1)
+        expect(index).to eq(1)
+      end
+    end
+  end
 
   [:rational32, :rational64, :rational128, :float32, :float64, :complex64, :complex128].each do |dtype|
     context dtype do
@@ -144,4 +159,4 @@ describe NMatrix::BLAS do
 
     end
   end
-end
+end

data/spec/elementwise_spec.rb

@@ -25,14 +25,9 @@
 # Element-wise operation tests.
 #
 
-# Can we use require_relative here instead?
-require File.join(File.dirname(__FILE__), "spec_helper.rb")
+require 'spec_helper'
 
 describe NMatrix do
-  #after :each do
-  #  GC.start
-  #end
-
   context "yale" do
     before :each do
       @n = NMatrix.new(3, stype: :yale, dtype: :int64)

data/spec/io_spec.rb

@@ -25,19 +25,12 @@
 # Basic tests for NMatrix::IO.
 #
 require "tmpdir" # Used to avoid cluttering the repository.
-
+require 'spec_helper'
 require "./lib/nmatrix"
 
 describe NMatrix::IO do
-  before :each do
-    @tmp_dir = Dir.mktmpdir
-    @test_out = File.join(@tmp_dir, "test-out")
-  end
-
-  after :each do
-    File.delete(@test_out) if File.file?(@test_out)
-    Dir.rmdir(@tmp_dir)
-  end
+  let(:tmp_dir)  { Dir.mktmpdir }
+  let(:test_out) { File.join(tmp_dir, 'test-out') }
 
   it "repacks a string" do
     expect(NMatrix::IO::Matlab.repack("hello", :miUINT8, :byte)).to eq("hello")
@@ -102,54 +95,54 @@ describe NMatrix::IO do
 
   it "reads and writes NMatrix dense" do
     n = NMatrix.new(:dense, [4,3], [0,1,2,3,4,5,6,7,8,9,10,11], :int32)
-    n.write(@test_out)
+    n.write(test_out)
 
-    m = NMatrix.read(@test_out)
+    m = NMatrix.read(test_out)
     expect(n).to eq(m)
   end
 
   it "reads and writes NMatrix dense as symmetric" do
     n = NMatrix.new(:dense, 3, [0,1,2,1,3,4,2,4,5], :int16)
-    n.write(@test_out, :symmetric)
+    n.write(test_out, :symmetric)
 
-    m = NMatrix.read(@test_out)
+    m = NMatrix.read(test_out)
     expect(n).to eq(m)
   end
 
   it "reads and writes NMatrix dense as skew" do
     n = NMatrix.new(:dense, 3, [0,1,2,-1,3,4,-2,-4,5], :float64)
-    n.write(@test_out, :skew)
+    n.write(test_out, :skew)
 
-    m = NMatrix.read(@test_out)
+    m = NMatrix.read(test_out)
     expect(n).to eq(m)
   end
 
   it "reads and writes NMatrix dense as hermitian" do
     n = NMatrix.new(:dense, 3, [0,1,2,1,3,4,2,4,5], :complex64)
-    n.write(@test_out, :hermitian)
+    n.write(test_out, :hermitian)
 
-    m = NMatrix.read(@test_out)
+    m = NMatrix.read(test_out)
     expect(n).to eq(m)
   end
 
   it "reads and writes NMatrix dense as upper" do
     n = NMatrix.new(:dense, 3, [-1,1,2,3,4,5,6,7,8], :int32)
-    n.write(@test_out, :upper)
+    n.write(test_out, :upper)
 
     m = NMatrix.new(:dense, 3, [-1,1,2,0,4,5,0,0,8], :int32) # lower version of the same
 
-    o = NMatrix.read(@test_out)
+    o = NMatrix.read(test_out)
     expect(o).to eq(m)
     expect(o).not_to eq(n)
   end
 
   it "reads and writes NMatrix dense as lower" do
     n = NMatrix.new(:dense, 3, [-1,1,2,3,4,5,6,7,8], :int32)
-    n.write(@test_out, :lower)
+    n.write(test_out, :lower)
 
     m = NMatrix.new(:dense, 3, [-1,0,0,3,4,0,6,7,8], :int32) # lower version of the same
 
-    o = NMatrix.read(@test_out)
+    o = NMatrix.read(test_out)
     expect(o).to eq(m)
     expect(o).not_to eq(n)
   end

data/spec/lapack_spec.rb

@@ -25,14 +25,9 @@
 # Tests for properly exposed LAPACK functions.
 #
 
-# Can we use require_relative here instead?
-require File.join(File.dirname(__FILE__), "spec_helper.rb")
+require 'spec_helper'
 
 describe NMatrix::LAPACK do
-  #after :each do
-  #  GC.start
-  #end
-
   # where integer math is allowed
   [:byte, :int8, :int16, :int32, :int64, :rational32, :rational64, :rational128, :float32, :float64, :complex64, :complex128].each do |dtype|
     context dtype do

data/spec/leakcheck.rb

@@ -13,4 +13,4 @@ require "./lib/nmatrix"
   n = NMatrix.new(:dense, 1000, :float64)
   n[0,t] = 1.0
   puts n[t,0]
-end
+end

data/spec/math_spec.rb

@@ -29,10 +29,6 @@
 require 'spec_helper'
 
 describe "math" do
-  #after :each do
-  #  GC.start
-  #end
-
   context "elementwise math functions" do
 
     [:dense,:list,:yale].each do |stype|
@@ -124,7 +120,50 @@ describe "math" do
             end
           end
         end
+          
+        context "Floor and ceil for #{stype}" do  
+
+          [:floor, :ceil].each do |meth|
+            [:byte,:int8,:int16,:int32,:int64, :float32,:float64, :object,:rational32,:rational64,:rational128, :complex64, :complex128].each do |dtype|
+              context dtype do
+                before :each do
+                  @size = [2,2]
+                  @m    = NMatrix.seq(@size, dtype: dtype, stype: stype)+1
+                  @a    = @m.to_a.flatten
+                end
 
+                if dtype.to_s.match(/int/) or [:byte, :object].include?(dtype)
+                  it "should return #{dtype} for #{dtype}" do
+                    
+                    expect(@m.send(meth)).to eq N.new(@size, @a.map { |e| e.send(meth) }, dtype: dtype, stype: stype)
+
+                    if dtype == :object
+                      expect(@m.send(meth).dtype).to eq :object
+                    else
+                      expect(@m.send(meth).integer_dtype?).to eq true
+                    end
+                  end
+                elsif dtype.to_s.match(/float/) or dtype.to_s.match(/rational/) 
+                  it "should return dtype int64 for #{dtype}" do
+
+                    expect(@m.send(meth)).to eq N.new(@size, @a.map { |e| e.send(meth) }, dtype: dtype, stype: stype)
+                    
+                    expect(@m.send(meth).dtype).to eq :int64
+                  end
+                elsif dtype.to_s.match(/complex/) 
+                  it "should properly calculate #{meth} for #{dtype}" do
+
+                    expect(@m.send(meth)).to eq N.new(@size, @a.map { |e| e = Complex(e.real.send(meth), e.imag.send(meth)) }, dtype: dtype, stype: stype)
+
+                    expect(@m.send(meth).dtype).to eq :complex64  if dtype == :complex64
+                    expect(@m.send(meth).dtype).to eq :complex128 if dtype == :complex128
+                  end
+                end
+              end
+            end
+          end
+        end
+        
       end
     end
   end

data/spec/nmatrix_yale_spec.rb

@@ -24,13 +24,10 @@
 #
 # Basic tests for NMatrix's Yale storage type.
 #
+require 'spec_helper'
 require "./lib/nmatrix"
 
 describe NMatrix do
-  #after :each do
-  #  GC.start
-  #end
-
   context :yale do
 
     it "compares two empty matrices" do

data/spec/rspec_spec.rb

@@ -24,7 +24,7 @@
 #
 # A spec for testing monkey patches to RSpec for NMatrix.
 #
-require File.join(File.dirname(__FILE__), "spec_helper.rb")
+require 'spec_helper'
 
 describe "RSpec" do
   it "should permit #be_within to be used on a dense NMatrix" do

data/spec/shortcuts_spec.rb

@@ -25,15 +25,10 @@
 # Specs for the shortcuts used in NMatrix and in NVector.
 #
 
-# Can we use require_relative here instead?
-require File.join(File.dirname(__FILE__), "spec_helper.rb")
+require 'spec_helper'
 require 'pry'
 
 describe NMatrix do
-  #after :each do
-  #  GC.start
-  #end
-
   it "zeros() creates a matrix of zeros" do
     m = NMatrix.zeros(3)
     n = NMatrix.new([3, 3], 0)

data/spec/slice_set_spec.rb

@@ -24,16 +24,12 @@
 #
 # Test of slice set operations.
 
+require 'spec_helper'
 require 'pry'
-require File.dirname(__FILE__) + "/spec_helper.rb"
 
 describe "Set slice operation" do
   include RSpec::Longrun::DSL
 
-  #after :each do
-  #  GC.start
-  #end
-
   [:dense, :yale, :list].each do |stype|
     context "for #{stype}" do
       before :each do

data/spec/stat_spec.rb

@@ -25,62 +25,59 @@
 # Tests for statistical functions in NMatrix.
 #
 
-# Can we use require_relative here instead?
-require File.join(File.dirname(__FILE__), "spec_helper.rb")
+require 'spec_helper'
 require 'pry'
 
 describe "Statistical functions" do
   context "mapping and reduction related functions" do
     [:dense, :yale, :list].each do |stype|
-      context "on #{stype} matrices" do 
-        before :each do
-          @nm_1d = NMatrix.new([5], [5.0,0.0,1.0,2.0,3.0], stype: stype) unless stype == :yale
-          @nm_2d = NMatrix.new([2,2], [0.0, 1.0, 2.0, 3.0], stype: stype)
-        end
+      context "on #{stype} matrices" do
+        let(:nm_1d) { NMatrix.new([5], [5.0,0.0,1.0,2.0,3.0], stype: stype) unless stype == :yale }
+        let(:nm_2d) { NMatrix.new([2,2], [0.0, 1.0, 2.0, 3.0], stype: stype) }
 
         it "behaves like Enumerable#reduce with no argument to reduce" do
-          expect(@nm_1d.reduce_along_dim(0) { |acc, el| acc + el }.to_f).to eq 11 unless stype == :yale
-          expect(@nm_2d.reduce_along_dim(1) { |acc, el| acc + el }).to eq NMatrix.new([2,1], [1.0, 5.0], stype: stype)
+          expect(nm_1d.reduce_along_dim(0) { |acc, el| acc + el }.to_f).to eq 11 unless stype == :yale
+          expect(nm_2d.reduce_along_dim(1) { |acc, el| acc + el }).to eq NMatrix.new([2,1], [1.0, 5.0], stype: stype)
         end
 
         it "should calculate the mean along the specified dimension" do
           unless stype == :yale then
-            puts @nm_1d.mean
-            expect(@nm_1d.mean).to eq NMatrix.new([1], [2.2], stype: stype, dtype: :float64)
+            puts nm_1d.mean
+            expect(nm_1d.mean).to eq NMatrix.new([1], [2.2], stype: stype, dtype: :float64)
           end
-          expect(@nm_2d.mean).to eq NMatrix[[1.0,2.0], stype: stype]
-          expect(@nm_2d.mean(1)).to eq NMatrix[[0.5], [2.5], stype: stype]
+          expect(nm_2d.mean).to eq NMatrix[[1.0,2.0], stype: stype]
+          expect(nm_2d.mean(1)).to eq NMatrix[[0.5], [2.5], stype: stype]
         end
 
         it "should calculate the minimum along the specified dimension" do
-          expect(@nm_1d.min).to eq 0.0 unless stype == :yale
-          expect(@nm_2d.min).to eq NMatrix[[0.0, 1.0], stype: stype]
-          expect(@nm_2d.min(1)).to eq NMatrix[[0.0], [2.0], stype: stype]
+          expect(nm_1d.min).to eq 0.0 unless stype == :yale
+          expect(nm_2d.min).to eq NMatrix[[0.0, 1.0], stype: stype]
+          expect(nm_2d.min(1)).to eq NMatrix[[0.0], [2.0], stype: stype]
         end
 
         it "should calculate the maximum along the specified dimension" do
-          expect(@nm_1d.max).to eq 5.0  unless stype == :yale
-          expect(@nm_2d.max).to eq NMatrix[[2.0, 3.0], stype: stype]
+          expect(nm_1d.max).to eq 5.0  unless stype == :yale
+          expect(nm_2d.max).to eq NMatrix[[2.0, 3.0], stype: stype]
         end
 
         it "should calculate the variance along the specified dimension" do
-          expect(@nm_1d.variance).to eq NMatrix[3.7, stype: stype] unless stype == :yale
-          expect(@nm_2d.variance(1)).to eq NMatrix[[0.5], [0.5], stype: stype]
+          expect(nm_1d.variance).to eq NMatrix[3.7, stype: stype] unless stype == :yale
+          expect(nm_2d.variance(1)).to eq NMatrix[[0.5], [0.5], stype: stype]
         end
 
         it "should calculate the sum along the specified dimension" do
-          expect(@nm_1d.sum).to eq NMatrix[11.0, stype: stype] unless stype == :yale
-          expect(@nm_2d.sum).to eq NMatrix[[2.0, 4.0], stype: stype]
+          expect(nm_1d.sum).to eq NMatrix[11.0, stype: stype] unless stype == :yale
+          expect(nm_2d.sum).to eq NMatrix[[2.0, 4.0], stype: stype]
         end
 
         it "should calculate the standard deviation along the specified dimension" do
-          expect(@nm_1d.std).to eq NMatrix[Math.sqrt(3.7), stype: stype] unless stype == :yale
-          expect(@nm_2d.std(1)).to eq NMatrix[[Math.sqrt(0.5)], [Math.sqrt(0.5)], stype: stype]
+          expect(nm_1d.std).to eq NMatrix[Math.sqrt(3.7), stype: stype] unless stype == :yale
+          expect(nm_2d.std(1)).to eq NMatrix[[Math.sqrt(0.5)], [Math.sqrt(0.5)], stype: stype]
         end
 
         it "should raise an ArgumentError when any invalid dimension is provided" do
-          expect { @nm_1d.mean(3) }.to raise_exception(RangeError) unless stype == :yale
-          expect { @nm_2d.mean(3) }.to raise_exception(RangeError)
+          expect { nm_1d.mean(3) }.to raise_exception(RangeError) unless stype == :yale
+          expect { nm_2d.mean(3) }.to raise_exception(RangeError)
         end
 
         it "should convert to float if it contains only a single element" do
@@ -90,65 +87,64 @@ describe "Statistical functions" do
         end
 
         it "should raise an index error if it contains more than a single element" do
-          expect { @nm_1d.to_f }.to raise_error(IndexError)  unless stype == :yale
-          expect { @nm_2d.to_f }.to raise_error(IndexError)
+          expect { nm_1d.to_f }.to raise_error(IndexError)  unless stype == :yale
+          expect { nm_2d.to_f }.to raise_error(IndexError)
         end
 
         it "should map a block to all elements" do
-          #binding.pry if stype == :list
-          expect(@nm_1d.map { |e| e ** 2 }).to eq NMatrix[25.0,0.0,1.0,4.0,9.0, stype: stype] unless stype == :yale
-          expect(@nm_2d.map { |e| e ** 2 }).to eq NMatrix[[0.0,1.0],[4.0,9.0], stype: stype]
+          expect(nm_1d.map { |e| e ** 2 }).to eq NMatrix[25.0,0.0,1.0,4.0,9.0, stype: stype] unless stype == :yale
+          expect(nm_2d.map { |e| e ** 2 }).to eq NMatrix[[0.0,1.0],[4.0,9.0], stype: stype]
         end
 
         it "should map! a block to all elements in place" do
           fct = Proc.new { |e| e ** 2 }
           unless stype == :yale then
-            expected1 = @nm_1d.map &fct
-            @nm_1d.map! &fct
-            expect(@nm_1d).to eq expected1
+            expected1 = nm_1d.map(&fct)
+            nm_1d.map!(&fct)
+            expect(nm_1d).to eq expected1
           end
-          expected2 = @nm_2d.map &fct
-          @nm_2d.map! &fct
-          expect(@nm_2d).to eq expected2
+          expected2 = nm_2d.map(&fct)
+          nm_2d.map!(&fct)
+          expect(nm_2d).to eq expected2
         end
 
         it "should return an enumerator for map without a block" do
-          expect(@nm_2d.map).to be_a Enumerator
+          expect(nm_2d.map).to be_a Enumerator
         end
 
         it "should return an enumerator for reduce without a block" do
-          expect(@nm_2d.reduce_along_dim(0)).to be_a Enumerator
+          expect(nm_2d.reduce_along_dim(0)).to be_a Enumerator
         end
 
         it "should return an enumerator for each_along_dim without a block" do
-          expect(@nm_2d.each_along_dim(0)).to be_a Enumerator
+          expect(nm_2d.each_along_dim(0)).to be_a Enumerator
         end
 
         it "should iterate correctly for map without a block" do
-          en = @nm_1d.map unless stype == :yale
-          expect(en.each { |e| e**2 }).to eq @nm_1d.map { |e| e**2 } unless stype == :yale
-          en = @nm_2d.map
-          expect(en.each { |e| e**2 }).to eq @nm_2d.map { |e| e**2 }
+          en = nm_1d.map unless stype == :yale
+          expect(en.each { |e| e**2 }).to eq nm_1d.map { |e| e**2 } unless stype == :yale
+          en = nm_2d.map
+          expect(en.each { |e| e**2 }).to eq nm_2d.map { |e| e**2 }
         end
 
         it "should iterate correctly for reduce without a block" do
           unless stype == :yale then
-            en = @nm_1d.reduce_along_dim(0, 1.0)
+            en = nm_1d.reduce_along_dim(0, 1.0)
             expect(en.each { |a, e| a+e }.to_f).to eq 12
           end
-          en = @nm_2d.reduce_along_dim(1, 1.0)
+          en = nm_2d.reduce_along_dim(1, 1.0)
           expect(en.each { |a, e| a+e }).to eq NMatrix[[2.0],[6.0], stype: stype]
         end
 
         it "should iterate correctly for each_along_dim without a block" do
           unless stype == :yale then
-            res = NMatrix.zeros_like(@nm_1d[0...1])
-            en = @nm_1d.each_along_dim(0)
+            res = NMatrix.zeros_like(nm_1d[0...1])
+            en = nm_1d.each_along_dim(0)
             en.each { |e| res += e }
             expect(res.to_f).to eq 11
           end
-          res = NMatrix.zeros_like (@nm_2d[0...2, 0])
-          en = @nm_2d.each_along_dim(1)
+          res = NMatrix.zeros_like (nm_2d[0...2, 0])
+          en = nm_2d.each_along_dim(1)
           en.each { |e| res += e }
           expect(res).to eq NMatrix[[1.0], [5.0], stype: stype]
         end
@@ -167,7 +163,6 @@ describe "Statistical functions" do
             acc
           end
 
-          m = NMatrix.new([2,3], [1,2,3,3,4,5], dtype: :complex128, stype: stype)
           m.reduce_along_dim(1, 0.0) do |acc, sub_m|
             expect(sub_m.dtype).to eq :complex128
             acc