nmatrix 0.0.4 → 0.0.5

data/lib/nmatrix/version.rb

@@ -26,6 +26,6 @@ class NMatrix
   # Note that the format of the VERSION string is needed for NMatrix
   # native IO. If you change the format, please make sure that native
   # IO can still understand NMatrix::VERSION.
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end
 

data/lib/nmatrix/yale_functions.rb

@@ -0,0 +1,112 @@
+#--
+# = NMatrix
+#
+# A linear algebra library for scientific computation in Ruby.
+# NMatrix is part of SciRuby.
+#
+# NMatrix was originally inspired by and derived from NArray, by
+# Masahiro Tanaka: http://narray.rubyforge.org
+#
+# == Copyright Information
+#
+# SciRuby is Copyright (c) 2010 - 2013, Ruby Science Foundation
+# NMatrix is Copyright (c) 2013, Ruby Science Foundation
+#
+# Please see LICENSE.txt for additional copyright notices.
+#
+# == Contributing
+#
+# By contributing source code to SciRuby, you agree to be bound by
+# our Contributor Agreement:
+#
+# * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+#
+# == yale_functions.rb
+#
+# This file contains some shortcut functions for the specialty
+# Yale matrix extensions (mostly for debugging and experimental
+# purposes, but sometimes applicable when you need to speed up
+# your code a lot).
+#++
+
+module NMatrix::YaleFunctions
+  # call-seq:
+  #     yale_nd_row_size(i) -> Fixnum
+  #
+  # Returns the size of a given non-diagonal row.
+  def yale_nd_row_size i
+    yale_ija(i+1) - yale_ija(i)
+  end
+
+  # call-seq:
+  #     yale_nd_row_as_array -> Array
+  #
+  # Returns the non-diagonal column indices which are stored in a given row.
+  def yale_nd_row_as_array i
+    yale_nd_row(i, :array)
+  end
+
+  # call-seq:
+  #     yale_nd_row_as_set -> Set
+  #
+  # Returns the non-diagonal column indices which are stored in a given row, as a Set.
+  def yale_nd_row_as_set i
+    require 'set'
+    yale_nd_row(i, :array).to_set
+  end
+
+  # call-seq:
+  #     yale_nd_row_as_sorted_set -> SortedSet
+  #
+  # Returns the non-diagonal column indices which are stored in a given row, as a Set.
+  def yale_nd_row_as_sorted_set i
+    require 'set'
+    SortedSet.new(yale_nd_row(i, :array))
+  end
+
+  # call-seq:
+  #     yale_nd_row_as_hash -> Hash
+  #
+  # Returns the non-diagonal column indices and entries stored in a given row.
+  def yale_nd_row_as_hash i
+    yale_nd_row(i, :hash)
+  end
+
+  # call-seq:
+  #     yale_row_as_array -> Array
+  #
+  # Returns the diagonal and non-digonal column indices stored in a given row.
+  def yale_row_as_array i
+    ary = yale_nd_row(i, :array)
+    return ary if i >= self.shape[1] || self[i,i].nil? || self[i,i] == 0
+    ary << i
+  end
+
+  # call-seq:
+  #     yale_row_as_set -> Set
+  #
+  # Returns the diagonal and non-diagonal column indices stored in a given row.
+  def yale_row_as_set i
+    require 'set'
+    yale_row_as_array(i).to_set
+  end
+
+  # call-seq:
+  #     yale_row_as_sorted_set -> SortedSet
+  #
+  # Returns the diagonal and non-diagonal column indices stored in a given row.
+  def yale_row_as_sorted_set i
+    require 'set'
+    SortedSet.new(yale_row_as_array(i))
+  end
+
+  # call-seq:
+  #     yale_row_as_hash -> Hash
+  #
+  # Returns the diagonal and non-diagonal column indices and entries stored in a given row.
+  def yale_row_as_hash i
+    h = yale_nd_row(i, :hash)
+    return h if i >= self.shape[1] || self[i,i].nil? || self[i,i] == 0
+    h[i] = self[i,i]
+  end
+end

data/spec/blas_spec.rb

@@ -170,6 +170,17 @@ describe NMatrix::BLAS do
         NMatrix::BLAS.gemv(a, x)
       end
 
+      it "exposes asum" do
+        x = NVector.new(4, [1,2,3,4], :float64)
+        NMatrix::BLAS.asum(x).should == 10.0
+      end
+
+
+      it "exposes nrm2" do
+        x = NVector.new(4, [2,-4,3,5], :float64)
+        NMatrix::BLAS.nrm2(x, 1, 3).should be_within(1e-10).of(5.385164807134504)
+      end
+
     end
   end
 end

data/spec/elementwise_spec.rb

@@ -74,7 +74,9 @@ describe NMatrix do
       (@n/m).should == r
     end
 
-    it "should perform element-wise modulo"
+    it "should perform element-wise modulo" do
+      pending "% operator not yet implemented for matrices"
+    end
 
     it "should handle element-wise equality (=~)" do
       (@n =~ @m).cast(:dense, :byte).should == NMatrix.new(:dense, 2, [0, 1, 1, 0], :byte)
@@ -131,6 +133,7 @@ describe NMatrix do
       end
 
       it "modulo" do
+        pending "% operator not yet implemented"
         r = @n % @m
         r.should == NMatrix.new(:dense, [2,2], [0, 1, 2, 3], :int64)
       end

data/spec/io_spec.rb

@@ -70,6 +70,14 @@ describe NMatrix::IO do
     `wc -l spec/utm5940.mtx`.split[0].should == `wc -l spec/utm5940.saved.mtx`.split[0]
   end
 
+  it "raises an error when reading a non-existent file" do
+    fn = rand(10000000).to_i.to_s
+    while File.exist?(fn)
+      fn = rand(10000000).to_i.to_s
+    end
+    expect{ NMatrix.read(fn) }.to raise_error(Errno::ENOENT)
+  end
+
   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")

data/spec/lapack_spec.rb

@@ -47,13 +47,26 @@ describe NMatrix::LAPACK do
       it "exposes clapack getrf" do
         a = NMatrix.new(:dense, 3, [4,9,2,3,5,7,8,1,6], dtype)
         NMatrix::LAPACK::clapack_getrf(:row, 3, 3, a, 3)
-        a[0,0].should == 8
-        a[0,1].should == 1
-        a[0,2].should == 6
-        a[1,0].should == 1.quo(2)
-        a[1,1].should == 17.quo(2)
-        a[1,2].should == -1
-        a[2,0].should == 3.quo(8)
+
+        # delta varies for different dtypes
+        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
+
+        a[0,0].should == 9 # 8
+        a[0,1].should be_within(err).of(2.quo(9)) # 1
+        a[0,2].should be_within(err).of(4.quo(9)) # 6
+        a[1,0].should == 5 # 1.quo(2)
+        a[1,1].should be_within(err).of(53.quo(9)) # 17.quo(2)
+        a[1,2].should be_within(err).of(7.quo(53)) # -1
+        a[2,0].should == 1 # 3.quo(8)
+        a[2,1].should be_within(err).of(52.quo(9))
+        a[2,2].should be_within(err).of(360.quo(53))
         # FIXME: these are rounded, == won't work
         #a[2,1].should == 0.544118
         #a[2,2].should == 5.294118
@@ -61,10 +74,14 @@ describe NMatrix::LAPACK do
 
       it "exposes clapack potrf" do
         # first do upper
-        a = NMatrix.new(:dense, 3, [25,15,-5, 0,18,0, 0,0,11], dtype)
-        NMatrix::LAPACK::clapack_potrf(:row, :upper, 3, a, 3)
-        b = NMatrix.new(:dense, 3, [5,3,-1, 0,3,1, 0,0,3], dtype)
-        a.should == b
+        begin
+          a = NMatrix.new(:dense, 3, [25,15,-5, 0,18,0, 0,0,11], dtype)
+          NMatrix::LAPACK::clapack_potrf(:row, :upper, 3, a, 3)
+          b = NMatrix.new(:dense, 3, [5,3,-1, 0,3,1, 0,0,3], dtype)
+          a.should == b
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
 
         # then do lower
         a = NMatrix.new(:dense, 3, [25,0,0, 15,18,0,-5,0,11], dtype)
@@ -89,13 +106,18 @@ describe NMatrix::LAPACK do
       it "exposes clapack getri" do
         a = NMatrix.new(:dense, 3, [1,0,4,1,1,6,-3,0,-10], dtype)
         ipiv = NMatrix::LAPACK::clapack_getrf(:row, 3, 3, a, 3) # get pivot from getrf, use for getri
-        NMatrix::LAPACK::clapack_getri(:row, 3, a, 3, ipiv)
 
-        b = NMatrix.new(:dense, 3, [-5,0,-2,-4,1,-1,1.5,0,0.5], dtype)
-        a.should == b
+        begin
+          NMatrix::LAPACK::clapack_getri(:row, 3, a, 3, ipiv)
+
+          b = NMatrix.new(:dense, 3, [-5,0,-2,-4,1,-1,1.5,0,0.5], dtype)
+          a.should == b
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
       end
 
 
     end
   end
-end
+end

data/spec/leakcheck.rb

@@ -0,0 +1,16 @@
+require "./lib/nmatrix"
+
+# Fixed:
+#n = NMatrix.new(:yale, [8,2], :int64)
+#m = NMatrix.new(:yale, [2,8], :int64)
+#100.times do
+#  n.dot(m)
+#end
+#GC.start
+
+# Remaining:
+100.times do |t|
+  n = NMatrix.new(:dense, 1000, :float64)
+  n[0,t] = 1.0
+  puts n[t,0]
+end

data/spec/math_spec.rb

@@ -50,7 +50,11 @@ describe "math" do
       it "should correctly invert a matrix" do
         a = NMatrix.new(:dense, 3, [1,0,4,1,1,6,-3,0,-10], dtype)
         b = NMatrix.new(:dense, 3, [-5,0,-2,-4,1,-1,1.5,0,0.5], dtype)
-        a.invert!
+        begin
+          a.invert!
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
         a.should == b
       end
     end
@@ -125,7 +129,7 @@ describe "math" do
         #STDERR.puts "2"
         n = 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], left_dtype)
 
-        m = NVector.new(3, [2.0, 1.0, 0.0], right_dtype)
+        m = NVector.new(3, [2.0, 1.0, 0.0], right_dtype).transpose
 
         m.shape[0].should == 3
         m.shape[1].should == 1

data/spec/nmatrix_spec.rb

@@ -25,8 +25,7 @@
 # Basic tests for NMatrix.
 #
 
-# Can we use require_relative here instead?
-require File.join(File.dirname(__FILE__), "spec_helper.rb")
+require File.dirname(__FILE__) + "/spec_helper.rb"
 
 describe NMatrix do
 
@@ -142,7 +141,7 @@ describe NMatrix do
 
   [:dense, :list, :yale].each do |storage_type|
     context storage_type do
-      it "can be duplicated" do
+    it "can be duplicated" do
         n = NMatrix.new(storage_type, [2,3], storage_type == :yale ? :float64 : 1.1)
         n.stype.should equal(storage_type)
 
@@ -292,8 +291,215 @@ describe NMatrix do
     end
   end
 
+  context "dense" do
+    it "should return the matrix being iterated over when each is called with a block" do
+      a = NMatrix.new(2, 1)
+      val = (a.each { })
+      val.should eq a
+    end
+    
+    it "should return the matrix being iterated over when each_stored_with_indices is called with a block" do
+      a = NMatrix.new(2,1)
+      val = (a.each_stored_with_indices { })
+      val.should eq a
+    end
+  end
+
+  [:list, :yale].each do |storage_type|
+    context storage_type do
+      it "should return the matrix being iterated over when each_stored_with_indices is called with a block" do
+        n = NMatrix.new(storage_type, [2,3], storage_type == :yale ? :float64 : 1.1)
+        val = (n.each_stored_with_indices { })
+        val.should eq n
+      end
+
+      it "should return an enumerator when each_stored_with_indices is called without a block" do
+        n = NMatrix.new(storage_type, [2,3], storage_type == :yale ? :float64 : 1.1)
+        val = n.each_stored_with_indices
+        val.should be_a Enumerator
+      end
+
+    end
+  end
+      
   it "should iterate through element 256 without a segfault" do
     t = NVector.random(256)
     t.each { |x| x + 0 }
   end
+
+  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]]
+    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]]
+    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]]
+    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]]
+    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]]
+    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]]
+    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]]
+    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)]]
+    end
+
+    it "should raise an ArgumentError when any invalid dimension is provided" do 
+      expect { @nm_1d.mean(3) }.to raise_exception(ArgumentError)
+    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
+    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)
+    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]]
+    end
+
+    it "should map! a block to all elements in place" do
+      fct = Proc.new { |e| e ** 2 }
+      expected1 = @nm_1d.map &fct
+      expected2 = @nm_2d.map &fct
+      @nm_1d.map! &fct
+      @nm_1d.should eq expected1
+      @nm_2d.map! &fct
+      @nm_2d.should eq expected2
+    end
+
+    it "should return an enumerator for map without a block" do
+      @nm_1d.map.should be_a Enumerator
+    end
+
+    it "should return an enumerator for reduce without a block" do
+      @nm_1d.reduce_along_dim(0).should be_a Enumerator
+    end
+
+    it "should return an enumerator for each_along_dim without a block" do
+      @nm_1d.each_along_dim(0).should be_a Enumerator
+    end
+
+    it "should iterate correctly for map without a block" do
+      en = @nm_1d.map
+      en.each { |e| e**2 }.should eq @nm_1d.map { |e| e**2 }
+      en = @nm_2d.map
+      en.each { |e| e**2 }.should eq @nm_2d.map { |e| e**2 }
+    end
+
+    it "should iterate correctly for reduce without a block" 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]]
+    end
+
+    it "should iterate correctly for each_along_dim without a block" do
+      res = NMatrix.zeros_like(@nm_1d[0...1])
+      en = @nm_1d.each_along_dim(0)
+      en.each { |e| res += e }
+      res.to_f.should eq 11
+
+      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]]
+    end
+
+    it "should yield matrices of matching dtype for each_along_dim" do
+      m = NMatrix.new([2,3], [1,2,3,3,4,5], :complex128)
+      m.each_along_dim(1) do |sub_m|
+        sub_m.dtype.should eq :complex128
+      end
+    end
+
+    it "should reduce to a matrix of matching dtype for reduce_along_dim" do
+      m = NMatrix.new([2,3], [1,2,3,3,4,5], :complex128)
+      m.reduce_along_dim(1) do |acc, sub_m|
+        sub_m.dtype.should eq :complex128
+        acc
+      end
+
+      m = NMatrix.new([2,3], [1,2,3,3,4,5], :complex128)
+      m.reduce_along_dim(1, 0.0) do |acc, sub_m|
+        sub_m.dtype.should eq :complex128
+        acc
+      end
+    end
+
+    it "should allow overriding the dtype for reduce_along_dim" do
+      m = N[[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.reduce_along_dim(1, nil, :float64) do |acc, sub_m|
+        acc.dtype.should eq :float64
+        acc
+      end
+    end
+
+    it "should convert integer dtypes to float when calculating mean" do
+      m = N[[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.mean(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.mean(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]]
+      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]]
+      end
+
+    end
+
+  end
+  
 end