nmatrix 0.0.2 → 0.0.3

data/lib/nmatrix/version.rb

@@ -22,6 +22,6 @@
 #
 
 class NMatrix
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end
 

data/spec/blas_spec.rb

@@ -31,17 +31,67 @@ require File.join(File.dirname(__FILE__), "spec_helper.rb")
 describe NMatrix::BLAS do
   [:rational32, :rational64, :rational128, :float32, :float64, :complex64, :complex128].each do |dtype|
     context dtype do
-      it "exposes cblas trsm, with B as a vector" do
-        a = NMatrix.new(:dense, 3, [5,4,-1,0,10,-3,0,0,1], dtype)
-        b = NVector.new(3, [0,11,3], dtype)
-        alpha = 1
-        NMatrix::BLAS::cblas_trsm(:row, :left, :upper, :no_transpose, :nonunit, b.shape[0], b.shape[1], alpha, a, 3, b, 1)
-        b[0].should == -1
-        b[1].should == 2
-        b[2].should == 3
+      it "exposes cblas trsm" do
+        a     = NMatrix.new(:dense, 3, [4,-1.quo(2), -3.quo(4), -2, 2, -1.quo(4), -4, -2, -1.quo(2)], dtype)
+        b     = NVector.new(3, [-1, 17, -9], dtype)
+        NMatrix::BLAS::cblas_trsm(:row, :right, :lower, :transpose, :nonunit, 1, 3, 1.0, a, 3, b, 3)
+
+        # These test results all come from actually running a matrix through BLAS. We use them to ensure that NMatrix's
+        # version of these functions (for rationals) give similar results.
+
+        b[0].should == -1.quo(4)
+        b[1].should == 33.quo(4)
+        b[2].should == -13
+
+        NMatrix::BLAS::cblas_trsm(:row, :right, :upper, :transpose, :unit, 1, 3, 1.0, a, 3, b, 3)
+
+        b[0].should == -15.quo(2)
+        b[1].should == 5
+        b[2].should == -13
+      end
+    end
+  end
+
+  [:rational32,:rational64,:rational128,:complex64,:complex128].each do |dtype|
+    context dtype do
+      it "exposes cblas rot"
+    end
+
+    context dtype do
+      it "exposes cblas rotg"
+    end
+  end
+
+  [:float32, :float64].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)
+        NMatrix::BLAS::cblas_rot(5, x, 1, y, -1, 0.5, Math.sqrt(3)/2)
+
+        x[0].should be_within(1e-4).of(-0.3660254037844386)
+        x[1].should be_within(1e-4).of(-0.7320508075688772)
+        x[2].should be_within(1e-4).of(-1.098076211353316)
+        x[3].should be_within(1e-4).of(-1.4641016151377544)
+        x[4].should be_within(1e-4).of(-1.8301270189221928)
+
+        y[0].should be_within(1e-4).of(-6.830127018922193)
+        y[1].should be_within(1e-4).of(-5.464101615137754)
+        y[2].should be_within(1e-4).of(-4.098076211353316)
+        y[3].should be_within(1e-4).of(-2.732050807568877)
+        y[4].should be_within(1e-4).of(-1.3660254037844386)
+      end
+
+      # FIXME: Need to write new Rational algorithm, which doesn't choke quite so often on irrational square roots (which often eventually cancel).
+      it "exposes cblas rotg" do
+        ab = NVector.new(2, [6,-8], dtype)
+        c,s = NMatrix::BLAS::cblas_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))
+        s.should be_within(1e-6).of(4.quo(5))
       end
 
-      it "exposes cblas trsm, with B as a matrix"
     end
   end
 end

data/spec/elementwise_spec.rb

@@ -35,55 +35,68 @@ describe NMatrix do
       @n = NMatrix.new(:list, 2, 0, :int64)
       @m = NMatrix.new(:list, 2, 0, :int64)
       @n[0,0] = 52
-      @m[0,0] = -48
+      @m[1,1] = -48
       @n[1,1] = 40
     end
 
+    it "should perform scalar math" do
+      x = @n * 3
+      x[0,0].should == 52 * 3
+      x[1,1].should == 40 * 3
+      x[0,1].should == 0
+
+      r = NMatrix.new(:list, 3, 1)
+      y = r + 3
+      y[0,0].should == 4
+    end
+
     it "should perform element-wise addition" do
-      r = NMatrix.new(:dense, 2, [4, 0, 0, 40], :int64).cast(:list, :int64)
+      r = NMatrix.new(:dense, 2, [52, 0, 0, -8], :int64).cast(:list, :int64)
       (@n+@m).should == r
     end
 
     it "should perform element-wise subtraction" do
-      r = NMatrix.new(:dense, 2, [100, 0, 0, 40], :int64).cast(:list, :int64)
+      r = NMatrix.new(:dense, 2, [52, 0, 0, -88], :int64).cast(:list, :int64)
       (@n-@m).should == r
     end
 
     it "should perform element-wise multiplication" do
-      r = NMatrix.new(:dense, 2, [-2496, 0, 0, 0], :int64).cast(:list, :int64)
-      (@n*@m).should == r
+      r = NMatrix.new(:dense, 2, [52, 0, 0, -1920], :int64).cast(:list, :int64)
+      m = NMatrix.new(:list, 2, 1, :int64)
+      m[1,1] = -48
+      (@n*m).should == r
     end
 
     it "should perform element-wise division" do
       m = NMatrix.new(:list, 2, 1, :int64)
       m[1,1] = 2
       r = NMatrix.new(:dense, 2, [52, 0, 0, 20], :int64).cast(:list, :int64)
-      (@n/@m).should == r
+      (@n/m).should == r
     end
 
     it "should perform element-wise modulo"
 
-    it "equals" do
+    it "should handle element-wise equality (=~)" do
       (@n =~ @m).cast(:dense, :byte).should == NMatrix.new(:dense, 2, [0, 1, 1, 0], :byte)
     end
 
-    it "is not equal to" do
+    it "should handle element-wise inequality (!~)" do
       (@n !~ @m).cast(:dense, :byte).should == NMatrix.new(:dense, 2, [1, 0, 0, 1], :byte)
     end
 
-    it "is less than" do
+    it "should handle element-wise less-than (<)" do
       (@n < @m).should == NMatrix.new(:list, 2, 0, :byte)
     end
 
-    it "is greater than" do
+    it "should handle element-wise greater-than (>)" do
       (@n > @m).should == NMatrix.new(:dense, 2, [1, 0, 0, 1], :byte).cast(:list, :byte)
     end
 
-    it "is greater than or equal to" do
+    it "should handle element-wise greater-than-or-equals (>=)" do
       (@n >= @m).cast(:dense, :byte).should == NMatrix.new(:dense, 2, [1, 1, 1, 1], :byte)
     end
 
-    it "is less than or equal to" do
+    it "should handle element-wise less-than-or-equals (<=)" do
       (@n <= @m).cast(:dense, :byte).should == NMatrix.new(:dense, 2, [0, 1, 1, 0], :byte)
     end
   end

data/spec/io_spec.rb

@@ -52,9 +52,77 @@ describe NMatrix::IO do
     n[3,3].should == 0
   end
 
-  it "reads MATLAB .mat file containing a single dense matrix" do
+  it "reads MATLAB .mat file containing a single dense integer matrix" do
     n = NMatrix::IO::Matlab.load_mat("spec/4x5_dense.mat")
     m = NMatrix.new(:dense, [4,5], [16,17,18,19,20,15,14,13,12,11,6,7,8,9,10,5,4,3,2,1])
     n.should == m
   end
+
+  it "reads MATLAB .mat file containing a single dense double matrix" do
+    n = NMatrix::IO::Matlab.load_mat("spec/2x2_dense_double.mat")
+    m = NMatrix.new(:dense, 2, [1.1, 2.0, 3.0, 4.0], :float64)
+    n.should == m
+  end
+
+  it "loads and saves MatrixMarket .mtx file containing a single large sparse double matrix" do
+    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]
+  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")
+
+    m = NMatrix.read("test-out")
+    n.should == 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)
+
+    m = NMatrix.read("test-out")
+    n.should == 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)
+
+    m = NMatrix.read("test-out")
+    n.should == 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)
+
+    m = NMatrix.read("test-out")
+    n.should == 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)
+
+    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.should == m
+    o.should_not == 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)
+
+    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.should == m
+    o.should_not == n
+  end
+
+
 end

data/spec/lapack_spec.rb

@@ -29,6 +29,19 @@
 require File.join(File.dirname(__FILE__), "spec_helper.rb")
 
 describe NMatrix::LAPACK do
+  # where integer math is allowed
+  [:byte, :int8, :int16, :int32, :int64, :rational32, :rational64, :rational128, :float32, :float64, :complex64, :complex128].each do |dtype|
+    context dtype do
+      it "exposes clapack laswp" do
+        a = NMatrix.new(:dense, [3,4], [1,2,3,4,5,6,7,8,9,10,11,12], dtype)
+        NMatrix::LAPACK::clapack_laswp(3, a, 4, 0, 3, [2,1,3,0], 1)
+        b = NMatrix.new(:dense, [3,4], [3,2,4,1,7,6,8,5,11,10,12,9], dtype)
+        a.should == b
+      end
+    end
+  end
+
+  # where integer math is not allowed
   [:rational32, :rational64, :rational128, :float32, :float64, :complex64, :complex128].each do |dtype|
     context dtype do
       it "exposes clapack getrf" do
@@ -37,16 +50,52 @@ describe NMatrix::LAPACK do
         a[0,0].should == 8
         a[0,1].should == 1
         a[0,2].should == 6
-        a[1,0].should == 0.5
-        a[1,1].should == 8.5
+        a[1,0].should == 1.quo(2)
+        a[1,1].should == 17.quo(2)
         a[1,2].should == -1
-        a[2,0].should == 0.375
+        a[2,0].should == 3.quo(8)
         # FIXME: these are rounded, == won't work
         #a[2,1].should == 0.544118
         #a[2,2].should == 5.294118
       end
 
-      it "exposes cblas trsm, with B as a matrix"
+      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
+
+        # then do lower
+        a = NMatrix.new(:dense, 3, [25,0,0, 15,18,0,-5,0,11], dtype)
+        NMatrix::LAPACK::clapack_potrf(:row, :lower, 3, a, 3)
+        b = NMatrix.new(:dense, 3, [5,0,0, 3,3,0, -1,1,3], dtype)
+        a.should == b
+      end
+
+      # Together, these calls are basically xGESV from LAPACK: http://www.netlib.org/lapack/double/dgesv.f
+      it "exposes clapack getrs" do
+        a     = NMatrix.new(:dense, 3, [-2,4,-3,3,-2,1,0,-4,3], dtype)
+        ipiv  = NMatrix::LAPACK::clapack_getrf(:row, 3, 3, a, 3)
+        b     = NVector.new(3, [-1, 17, -9], dtype)
+
+        NMatrix::LAPACK::clapack_getrs(:row, false, 3, 1, a, 3, ipiv, b, 3)
+
+        b[0].should == 5
+        b[1].should == -15.quo(2)
+        b[2].should == -13
+      end
+
+      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
+      end
+
+
     end
   end
 end

data/spec/math_spec.rb

@@ -45,6 +45,15 @@ describe "math" do
         a[2,0].should == 0.375
       end
     end
+
+    context dtype 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!
+        a.should == b
+      end
+    end
   end
 
   [:float32, :float64, :complex64, :complex128].each do |dtype|

data/spec/nmatrix_list_spec.rb

@@ -0,0 +1,95 @@
+# = 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 - 2012, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012, 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
+#
+# == nmatrix_list_spec.rb
+#
+# Basic tests for NMatrix's list-of-lists storage type.
+#
+require "./lib/nmatrix"
+
+describe NMatrix do
+  context :list do
+  it "should compare with ==" do
+    n = NMatrix.new(:list, [3,3,3], :int64)
+    m = NMatrix.new(:list, [3,3,3], :int64)
+    n.should == m
+    n[0,0,0] = 5
+    n.should_not == m
+    n[0,0,1] = 52
+    n[1,2,1] = -4
+
+    m[0,0,0] = 5
+    m[0,0,1] = 52
+    m[1,2,1] = -4
+    n.should == m
+  end
+
+  it "should handle missing default value" do
+    NMatrix.new(:list, 3, :int8)[0,0].should    == 0
+    NMatrix.new(:list, 4, :float64)[0,0].should == 0.0
+  end
+
+  it "should allow conversion to a Ruby Hash" do
+    n = NMatrix.new(:list, 3, 1, :int64)
+    n[0,1] = 50
+    h = n.to_h
+    h.size.should == 1
+    h[0].size.should == 1
+    h[0][1].should == 50
+    h[0][2].should == 1
+    h[1][0].should == 1
+  end
+
+
+  ##TODO: Make this test better. It's not nearly exhaustive enough as is.
+  it "should handle recursive removal" do
+    n = NMatrix.new(:list, [3,3,3], 0)
+    n[0,0,0] = 2
+    n[1,1,1] = 1
+    n[1,0,0] = 3
+    n[0,0,1] = 4
+
+    n[0,0,0].should == 2
+    n[1,1,1].should == 1
+    n[1,0,0].should == 3
+    n[0,0,1].should == 4
+
+    n[1,1,1] = 0
+    n[0,0,0].should == 2
+    n[1,1,1].should == 0
+    n[1,0,0].should == 3
+    n[0,0,1].should == 4
+  end
+
+  it "should correctly insert a value between the middle and last entries of a three-element list" do
+    n = NMatrix.new(:list, 5940, 0, :float64)
+    n[0,0] = -7.0710685196786e-01
+    n[330,0] = 7.0710685196786e-01
+    n[1,0] = -7.0710685196786e-01
+    n[2,0] = -7.0710685196786e-01
+    n[0,0].should_not == 0
+    n[330,0].should_not == 0
+    n[2,0].should_not == 0
+    n[1,0].should_not == 0
+  end
+  end
+end

data/spec/nmatrix_spec.rb

@@ -35,6 +35,11 @@ describe NMatrix do
     x = a.det_exact
   end
 
+  it "calculates determinants" do
+    m = NMatrix.new(:dense, 3, [-2,2,3,-1,1,3,2,0,-1])
+    m.det.should == 6
+  end
+
   it "allows stype casting of a dim 2 matrix between dense, sparse, and list (different dtypes)" do
     m = NMatrix.new(:dense, [3,3], [0,0,1,0,2,0,3,4,5], :int64).
         cast(:yale, :int32).
@@ -51,21 +56,6 @@ describe NMatrix do
   end
 
 
-  it "compares two list matrices" do
-    n = NMatrix.new(:list, [3,3,3], :int64)
-    m = NMatrix.new(:list, [3,3,3], :int64)
-    n.should == m
-    n[0,0,0] = 5
-    n.should_not == m
-    n[0,0,1] = 52
-    n[1,2,1] = -4
-
-    m[0,0,0] = 5
-    m[0,0,1] = 52
-    m[1,2,1] = -4
-    n.should == m
-  end
-
   it "fills dense Ruby object matrix with nil" do
     n = NMatrix.new([4,3], :object)
     n[0,0].should == nil
@@ -134,44 +124,6 @@ describe NMatrix do
   end
 
 
-  it "list handles missing initialization value" do
-    NMatrix.new(:list, 3, :int8)[0,0].should    == 0
-    NMatrix.new(:list, 4, :float64)[0,0].should == 0.0
-  end
-
-  it "should allow conversion of list storage to a Ruby Hash" do
-    n = NMatrix.new(:list, 3, 1, :int64)
-    n[0,1] = 50
-    h = n.to_h
-    h.size.should == 1
-    h[0].size.should == 1
-    h[0][1].should == 50
-    h[0][2].should == 1
-    h[1][0].should == 1
-  end
-
-
-  ##TODO: Make this test better. It's not nearly exhaustive enough as is.
-  it "list handles recursive removal" do
-    n = NMatrix.new(:list, [3,3,3], 0)
-    n[0,0,0] = 2
-    n[1,1,1] = 1
-    n[1,0,0] = 3
-    n[0,0,1] = 4
-
-    n[0,0,0].should == 2
-    n[1,1,1].should == 1
-    n[1,0,0].should == 3
-    n[0,0,1].should == 4
-
-    n[1,1,1] = 0
-    n[0,0,0].should == 2
-    n[1,1,1].should == 0
-    n[1,0,0].should == 3
-    n[0,0,1].should == 4
-  end
-
-
   it "dense handles missing initialization value" do
     n = NMatrix.new(3, :int8)
     n.stype.should == :dense
@@ -336,6 +288,11 @@ describe NMatrix do
         NMatrix.new(storage_type, [3,2,8], 0).shape.should == [3,2,8]
         NMatrix.new(storage_type, [3,2,8], 0).dim.should  == 3
       end
+      
+      it "returns number of rows and columns" do
+        NMatrix.new(storage_type, [7, 4], 3).rows.should == 7
+        NMatrix.new(storage_type, [7, 4], 3).cols.should == 4
+      end
     end unless storage_type == :yale
   end