nmatrix-atlas 0.2.0

data/spec/nmatrix_yale_spec.rb

@@ -0,0 +1,286 @@
+# = 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 - 2014, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2014, John Woods and the 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_yale_spec.rb
+#
+# Basic tests for NMatrix's Yale storage type.
+#
+require 'spec_helper'
+require "./lib/nmatrix"
+
+describe NMatrix do
+  context :yale do
+
+    it "compares two empty matrices" do
+      n = NMatrix.new(4, stype: :yale, dtype: :float64)
+      m = NMatrix.new(4, stype: :yale, dtype: :float64)
+      expect(n).to eq(m)
+    end
+
+    it "compares two matrices following basic assignments" do
+      n = NMatrix.new(2, stype: :yale, dtype: :float64)
+      m = NMatrix.new(2, stype: :yale, dtype: :float64)
+
+      m[0,0] = 1
+      m[0,1] = 1
+      expect(n).not_to eq(m)
+      n[0,0] = 1
+      expect(n).not_to eq(m)
+      n[0,1] = 1
+      expect(n).to eq(m)
+    end
+
+    it "compares two matrices following elementwise operations" do
+      n = NMatrix.new(2, stype: :yale, dtype: :float64)
+      m = NMatrix.new(2, stype: :yale, dtype: :float64)
+      n[0,1] = 1
+      m[0,1] = -1
+      x = n+m
+      expect(n+m).to eq(NMatrix.new(2, 0.0, stype: :yale))
+    end
+
+    it "sets diagonal values" do
+      n = NMatrix.new([2,3], stype: :yale, dtype: :float64)
+      n.extend(NMatrix::YaleFunctions)
+      n[1,1] = 0.1
+      n[0,0] = 0.2
+      expect(n.yale_d).to eq([0.2, 0.1])
+    end
+
+    it "gets non-diagonal rows as hashes" do
+      n = NMatrix.new([4,6], stype: :yale, dtype: :float64)
+      n.extend(NMatrix::YaleFunctions)
+      n[0,0] = 0.1
+      n[0,2] = 0.2
+      n[0,3] = 0.3
+      n[1,5] = 0.4
+      h = n.yale_nd_row(0, :hash)
+      expect(h).to eq({2 => 0.2, 3 => 0.3})
+    end
+
+    it "gets non-diagonal occupied column indices for a given row" do
+      n = NMatrix.new([4,6], stype: :yale, dtype: :float64)
+      n.extend(NMatrix::YaleFunctions)
+      n[0,0] = 0.1
+      n[0,2] = 0.2
+      n[0,3] = 0.3
+      n[1,5] = 0.4
+      a = n.yale_nd_row(0, :array)
+      expect(a).to eq([2,3])
+    end
+
+    it "does not resize until necessary" do
+      n = NMatrix.new([2,3], stype: :yale, dtype: :float64)
+      n.extend(NMatrix::YaleFunctions)
+      expect(n.yale_size).to eq(3)
+      expect(n.capacity).to eq(5)
+      n[0,0] = 0.1
+      n[0,1] = 0.2
+      n[1,0] = 0.3
+      expect(n.yale_size).to eq(5)
+      expect(n.capacity).to eq(5)
+    end
+
+
+    it "sets when not resizing" do
+      n = NMatrix.new([2,3], stype: :yale, dtype: :float64)
+      n.extend(NMatrix::YaleFunctions)
+      n[0,0] = 0.1
+      n[0,1] = 0.2
+      n[1,0] = 0.3
+      expect(n.yale_a).to eq([0.1, 0.0, 0.0, 0.2, 0.3])
+      expect(n.yale_ija).to eq([3,4,5,1,0])
+    end
+
+    it "sets when resizing" do
+      n = NMatrix.new([2,3], stype: :yale, dtype: :float64)
+      n.extend(NMatrix::YaleFunctions)
+      n[0,0] = 0.01
+      n[1,1] = 0.1
+      n[0,1] = 0.2
+      n[1,0] = 0.3
+      n[1,2] = 0.4
+      expect(n.yale_d).to eq([0.01, 0.1])
+      expect(n.yale_ia).to eq([3,4,6])
+      expect(n.yale_ja).to eq([1,0,2,nil])
+      expect(n.yale_lu).to eq([0.2, 0.3, 0.4, nil])
+    end
+
+    it "resizes without erasing values" do
+      require 'yaml'
+
+      associations = File.open('spec/nmatrix_yale_resize_test_associations.yaml') { |y| YAML::load(y) }
+
+      n = NMatrix.new([618,2801], stype: :yale, dtype: :byte, capacity: associations.size)
+      #n = NMatrix.new(:yale, [618, 2801], associations.size, :byte)
+
+      associations.each_pair do |j,i|
+        n[i,j] = 1
+        expect(n[i,j]).to be(1), "Value at #{i},#{j} not inserted correctly!"
+      end
+
+      associations.each_pair do |j,i|
+        expect(n[i,j]).to be(1), "Value at #{i},#{j} erased during resize!"
+      end
+    end
+
+    it "sets values within rows" do
+      n = NMatrix.new([3,20], stype: :yale, dtype: :float64)
+      n.extend(NMatrix::YaleFunctions)
+      n[2,1]   = 1.0
+      n[2,0]   = 1.5
+      n[2,15]  = 2.0
+      expect(n.yale_lu).to eq([1.5, 1.0, 2.0])
+      expect(n.yale_ja).to eq([0, 1, 15])
+    end
+
+    it "gets values within rows" do
+      n = NMatrix.new([3,20], stype: :yale, dtype: :float64)
+      n[2,1]   = 1.0
+      n[2,0]   = 1.5
+      n[2,15]  = 2.0
+      expect(n[2,1]).to eq(1.0)
+      expect(n[2,0]).to eq(1.5)
+      expect(n[2,15]).to eq(2.0)
+    end
+
+    it "sets values within large rows" do
+      n = NMatrix.new([10,300], stype: :yale, dtype: :float64)
+      n.extend(NMatrix::YaleFunctions)
+      n[5,1]   = 1.0
+      n[5,0]   = 1.5
+      n[5,15]  = 2.0
+      n[5,291] = 3.0
+      n[5,292] = 4.0
+      n[5,289] = 5.0
+      n[5,290] = 6.0
+      n[5,293] = 2.0
+      n[5,299] = 7.0
+      n[5,100] = 8.0
+      expect(n.yale_lu).to eq([1.5, 1.0, 2.0, 8.0, 5.0, 6.0, 3.0, 4.0, 2.0, 7.0])
+      expect(n.yale_ja).to eq([0,   1,   15,  100, 289, 290, 291, 292, 293, 299])
+    end
+
+    it "gets values within large rows" do
+      n = NMatrix.new([10,300], stype: :yale, dtype: :float64)
+      n.extend(NMatrix::YaleFunctions)
+      n[5,1]   = 1.0
+      n[5,0]   = 1.5
+      n[5,15]  = 2.0
+      n[5,291] = 3.0
+      n[5,292] = 4.0
+      n[5,289] = 5.0
+      n[5,290] = 6.0
+      n[5,293] = 2.0
+      n[5,299] = 7.0
+      n[5,100] = 8.0
+
+      n.yale_ja.each_index do |idx|
+        j = n.yale_ja[idx]
+        expect(n[5,j]).to eq(n.yale_lu[idx])
+      end
+    end
+
+    it "dots two identical matrices" do
+      a = NMatrix.new(4, stype: :yale, dtype: :float64)
+      a[0,1] = 4.0
+      a[1,2] = 1.0
+      a[1,3] = 1.0
+      a[3,1] = 2.0
+
+      b = a.dup
+      c = a.dot b
+
+      d = NMatrix.new(4, [0,0,4,4, 0,2,0,0, 0,0,0,0, 0,0,2,2], dtype: :float64, stype: :yale)
+
+      expect(c).to eq(d)
+    end
+
+    it "dots two identical matrices where a positive and negative partial sum cancel on the diagonal" do
+      a = NMatrix.new(4, 0.0, stype: :yale)
+
+      a[0,0] = 1.0
+      a[0,1] = 4.0
+      a[1,2] = 2.0
+      a[1,3] = -4.0
+      a[3,1] = 4.0
+      a[3,3] = 4.0
+
+      b = a.dup
+      c = a.dot b
+
+      c.extend(NMatrix::YaleFunctions)
+
+      expect(c.yale_ija.reject { |i| i.nil? }).to eq([5,8,9,9,11,1,2,3,3,1,2])
+      expect(c.yale_a.reject { |i| i.nil? }).to eq([1.0, -16.0, 0.0, 0.0, 0.0, 4.0, 8.0, -16.0, -16.0, 16.0, 8.0])
+
+    end
+
+    it "dots two vectors" do
+      n = NMatrix.new([16,1], 0, stype: :yale)
+      m = NMatrix.new([1,16], 0, stype: :yale)
+
+      n[0] = m[0] = 1
+      n[1] = m[1] = 2
+      n[2] = m[2] = 3
+      n[3] = m[3] = 4
+      n[4] = m[4] = 5
+      n[5] = m[5] = 6
+      n[6] = m[6] = 7
+      n[7] = m[7] = 8
+      n[8] = m[8] = 9
+      n[15] = m[15] = 16
+
+      nm = n.dot(m)
+
+      # Perform the same multiplication with dense
+      nmr = n.cast(:dense, :int64).dot(m.cast(:dense, :int64)).cast(:yale, :int64)
+
+      nm.extend(NMatrix::YaleFunctions)
+      nmr.extend(NMatrix::YaleFunctions)
+
+      # We want to do a structure comparison to ensure multiplication is occurring properly, but more importantly, to
+      # ensure that insertion sort is occurring as it should. If the row has more than four entries, it'll run quicksort
+      # instead. Quicksort calls insertion sort for small rows, so we test both with this particular multiplication.
+      expect(nm.yale_ija[0...107]).to eq(nmr.yale_ija[0...107])
+      expect(nm.yale_a[0...107]).to   eq(nmr.yale_a[0...107])
+
+      mn = m.dot(n)
+      expect(mn[0,0]).to eq(541)
+    end
+
+    it "calculates the row key intersections of two matrices" do
+      a = NMatrix.new([3,9], [0,1], stype: :yale, dtype: :byte, default: 0)
+      b = NMatrix.new([3,9], [0,0,1,0,1], stype: :yale, dtype: :byte, default: 0)
+      a.extend NMatrix::YaleFunctions
+      b.extend NMatrix::YaleFunctions
+
+      (0...3).each do |ai|
+        (0...3).each do |bi|
+          STDERR.puts (a.yale_ja_d_keys_at(ai) & b.yale_ja_d_keys_at(bi)).inspect
+          expect(a.yale_ja_d_keys_at(ai) & b.yale_ja_d_keys_at(bi)).to eq(a.yale_row_keys_intersection(ai, b, bi))
+        end
+      end
+
+    end
+  end
+end

data/spec/plugins/atlas/atlas_spec.rb

@@ -0,0 +1,242 @@
+# = 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 - 2014, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2014, John Woods and the 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
+#
+# == atlas_spec.rb
+#
+# Tests for interfaces that are only exposed by nmatrix-atlas
+#
+
+require 'spec_helper'
+require "./lib/nmatrix/atlas"
+
+describe "NMatrix::LAPACK implementation from nmatrix-atlas plugin" do
+  [:float32, :float64, :complex64, :complex128].each do |dtype|
+    context dtype 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
+
+        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)
+          expect(a).to eq(b)
+        rescue NotImplementedError => e
+          pending e.to_s
+        end
+      end
+
+      # potrf decomposes a symmetric (or Hermitian)
+      # positive-definite matrix. The matrix tested below isn't symmetric.
+      # But this is okay since potrf just examines the upper/lower half
+      # (as requested) of the matrix and assumes that the rest is symmetric,
+      # so we just set the other part of the matrix to zero.
+      it "exposes clapack_potrf upper" do
+        pending "potrf requires clapack" unless NMatrix.has_clapack?
+
+        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)
+        expect(a).to eq(b)
+      end
+
+      it "exposes clapack_potrf lower" do
+        pending "potrf requires clapack" unless NMatrix.has_clapack?
+
+        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)
+        expect(a).to eq(b)
+      end
+
+      it "exposes clapack_potri" do
+        pending "potri requires clapack" unless NMatrix.has_clapack?
+
+        a = NMatrix.new(3, [4, 0,-1,
+                            0, 2, 1,
+                            0, 0, 1], dtype: dtype)
+        NMatrix::LAPACK::clapack_potrf(:row, :upper, 3, a, 3)
+        NMatrix::LAPACK::clapack_potri(:row, :upper, 3, a, 3)
+        b = NMatrix.new(3, [0.5, -0.5, 1,  0, 1.5, -2,  0, 0, 4], dtype: dtype)
+        err = case dtype
+                when :float32, :complex64
+                  1e-6
+                when :float64, :complex128
+                  1e-14
+              end
+        expect(a).to be_within(err).of(b)
+      end
+
+      it "exposes clapack_potrs" do
+        pending "potrs requires clapack" unless NMatrix.has_clapack?
+
+        a = NMatrix.new(3, [4, 0,-1,
+                            0, 2, 1,
+                            0, 0, 1], dtype: dtype)
+        b = NMatrix.new([3,1], [3,0,2], dtype: dtype)
+
+        NMatrix::LAPACK::clapack_potrf(:row, :upper, 3, a, 3)
+        NMatrix::LAPACK::clapack_potrs(:row, :upper, 3, 1, a, 3, b, 3)
+
+        x = NMatrix.new([3,1], [3.5, -5.5, 11], dtype: dtype)
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-5
+                when :float64, :complex128
+                  1e-14
+              end
+
+        expect(b).to be_within(err).of(x)
+      end
+    end
+  end
+
+  [:float32, :float64, :complex64, :complex128].each do |dtype|
+    context dtype do
+      it "calculates the singular value decomposition with lapack_gesvd" do
+        #example from Wikipedia
+        m = 4
+        n = 5
+        mn_min = [m,n].min
+        a = NMatrix.new([m,n],[1,0,0,0,2, 0,0,3,0,0, 0,0,0,0,0, 0,4,0,0,0], dtype: dtype)
+        s = NMatrix.new([mn_min], 0, dtype: a.abs_dtype) #s is always real and always returned as float/double, never as complex
+        u = NMatrix.new([m,m], 0, dtype: dtype)
+        vt = NMatrix.new([n,n], 0, dtype: dtype)
+
+        # This is a pure LAPACK function so it expects column-major functions
+        # So we need to transpose the input as well as the output
+        a = a.transpose
+        NMatrix::LAPACK.lapack_gesvd(:a, :a, m, n, a, m, s, u, m, vt, n, 500)
+        u = u.transpose
+        vt = vt.transpose
+
+        s_true = NMatrix.new([mn_min], [4,3,Math.sqrt(5),0], dtype: a.abs_dtype)
+        u_true = NMatrix.new([m,m], [0,0,1,0, 0,1,0,0, 0,0,0,-1, 1,0,0,0], dtype: dtype)
+        vt_true = NMatrix.new([n,n], [0,1,0,0,0, 0,0,1,0,0, Math.sqrt(0.2),0,0,0,Math.sqrt(0.8), 0,0,0,1,0, -Math.sqrt(0.8),0,0,0,Math.sqrt(0.2)], dtype: dtype)
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-5
+                when :float64, :complex128
+                  1e-14
+              end
+
+        expect(s).to be_within(err).of(s_true)
+        expect(u).to be_within(err).of(u_true)
+        expect(vt).to be_within(err).of(vt_true)
+      end
+
+      it "calculates the singular value decomposition with lapack_gesdd" do
+        #example from Wikipedia
+        m = 4
+        n = 5
+        mn_min = [m,n].min
+        a = NMatrix.new([m,n],[1,0,0,0,2, 0,0,3,0,0, 0,0,0,0,0, 0,4,0,0,0], dtype: dtype)
+        s = NMatrix.new([mn_min], 0, dtype: a.abs_dtype) #s is always real and always returned as float/double, never as complex
+        u = NMatrix.new([m,m], 0, dtype: dtype)
+        vt = NMatrix.new([n,n], 0, dtype: dtype)
+
+        # This is a pure LAPACK function so it expects column-major functions
+        # So we need to transpose the input as well as the output
+        a = a.transpose
+        NMatrix::LAPACK.lapack_gesdd(:a, m, n, a, m, s, u, m, vt, n, 500)
+        u = u.transpose
+        vt = vt.transpose
+
+        s_true = NMatrix.new([mn_min], [4,3,Math.sqrt(5),0], dtype: a.abs_dtype)
+        u_true = NMatrix.new([m,m], [0,0,1,0, 0,1,0,0, 0,0,0,-1, 1,0,0,0], dtype: dtype)
+        vt_true = NMatrix.new([n,n], [0,1,0,0,0, 0,0,1,0,0, Math.sqrt(0.2),0,0,0,Math.sqrt(0.8), 0,0,0,1,0, -Math.sqrt(0.8),0,0,0,Math.sqrt(0.2)], dtype: dtype)
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-5
+                when :float64, :complex128
+                  1e-14
+              end
+
+        expect(s).to be_within(err).of(s_true)
+        expect(u).to be_within(err).of(u_true)
+        expect(vt).to be_within(err).of(vt_true)
+      end
+
+      it "exposes lapack_geev" do
+        n = 3
+        a = NMatrix.new([n,n], [-1,0,0, 0,1,-2, 0,1,-1], dtype: dtype)
+        w = NMatrix.new([n], dtype: dtype)
+        if a.complex_dtype? #for real dtypes, imaginary parts of eigenvalues are stored in separate vector
+          wi = nil
+        else
+          wi = NMatrix.new([n], dtype: dtype)
+        end
+        vl = NMatrix.new([n,n], dtype: dtype)
+        vr = NMatrix.new([n,n], dtype: dtype)
+
+        # This is a pure LAPACK routine so it expects column-major matrices,
+        # so we need to transpose everything.
+        a = a.transpose
+        NMatrix::LAPACK::lapack_geev(:left, :right, n, a, n, w, wi, vl, n, vr, n, 2*n)
+        vr = vr.transpose
+        vl = vl.transpose
+
+        if !a.complex_dtype?
+          w = w + wi*Complex(0,1)
+        end
+
+        w_true = NMatrix.new([n], [Complex(0,1), -Complex(0,1), -1], dtype: NMatrix.upcast(dtype, :complex64))
+        if a.complex_dtype?
+          #For complex types the right/left eigenvectors are stored as columns
+          #of vr/vl.
+          vr_true = NMatrix.new([n,n],[0,0,1,
+                                       2/Math.sqrt(6),2/Math.sqrt(6),0,
+                                       Complex(1,-1)/Math.sqrt(6),Complex(1,1)/Math.sqrt(6),0], dtype: dtype)
+          vl_true = NMatrix.new([n,n],[0,0,1,
+                                       Complex(-1,1)/Math.sqrt(6),Complex(-1,-1)/Math.sqrt(6),0,
+                                       2/Math.sqrt(6),2/Math.sqrt(6),0], dtype: dtype)
+        else
+          #For real types, the real part of the first and second eigenvectors is
+          #stored in the first column, the imaginary part of the first (= the
+          #negative of the imaginary part of the second) eigenvector is stored
+          #in the second column, and the third eigenvector (purely real) is the
+          #third column.
+          vr_true = NMatrix.new([n,n],[0,0,1,
+                                       2/Math.sqrt(6),0,0,
+                                       1/Math.sqrt(6),-1/Math.sqrt(6),0], dtype: dtype)
+          vl_true = NMatrix.new([n,n],[0,0,1,
+                                       -1/Math.sqrt(6),1/Math.sqrt(6),0,
+                                       2/Math.sqrt(6),0,0], dtype: dtype)
+        end
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-6
+                when :float64, :complex128
+                  1e-15
+              end
+
+        expect(w).to be_within(err).of(w_true)
+        expect(vr).to be_within(err).of(vr_true)
+        expect(vl).to be_within(err).of(vl_true)
+      end
+    end
+  end
+end