nulin 0.2

data/tests/test_lls.rb

@@ -0,0 +1,51 @@
+require 'test-unit'
+require 'nulin'
+require 'complex'
+
+class TestNuLin_lls < Test::Unit::TestCase
+  def test_lls
+    a = NMatrix[[0.4, 0.1],
+                [-1.2, 0.9],
+                [0.1, -0.6]]
+    b = NVector[0.7,-1.0,0.4]
+    
+    lls = NuLin.lls(a, b)
+    assert_equal([2], lls.solution.shape)
+    assert_narray_in_delta((a.transpose*a).inverse * a.transpose * b, lls.solution)
+    
+    lls = NuLin.lls(a, b, algorithm: :svd)
+    assert_equal([2], lls.solution.shape)
+    assert_narray_in_delta((a.transpose*a).inverse * a.transpose * b, lls.solution)
+    assert_narray_in_delta(NuLin.svd(a).singular_values, lls.singular_values)
+    assert_equal(2, lls.rank)
+    
+    b = NVector[[0.7,-1.0,0.4], [1.2, 0.8, -0.1]]
+    lls = NuLin.lls(a, b)
+    
+    assert_narray_in_delta((a.transpose*a).inverse * a.transpose * b[true, 0],
+                           lls.solution[true, 0])
+    assert_narray_in_delta((a.transpose*a).inverse * a.transpose * b[true, 1],
+                           lls.solution[true, 1])
+    
+    lls = NuLin.lls(a, b, algorithm: :svd)
+    assert_narray_in_delta((a.transpose*a).inverse * a.transpose * b[true, 0],
+                           lls.solution[true, 0])
+    assert_narray_in_delta((a.transpose*a).inverse * a.transpose * b[true, 1],
+                           lls.solution[true, 1])
+
+    a = NMatrix[[Complex(1.2, 0.2), Complex(0.1, -0.1)],
+                [Complex(-1.2, -0.2), Complex(-0.9, 1.0)],
+                [Complex(0.34, 0.1), Complex(-0.1, -0.1)]]
+    b = NVector[Complex(0.7), -1.0, Complex(0.1, 0.4)]
+
+    lls = NuLin.lls(a, b)
+    assert_narray_in_delta((a.adjoint*a).inverse * a.adjoint * b, lls.solution)
+
+    lls = NuLin.lls(a, b, algorithm: :svd)
+    assert_narray_in_delta((a.adjoint*a).inverse * a.adjoint * b, lls.solution)
+
+    a = NMatrix.float(2, 3); b = NVector.float(2)
+    assert_raise(NuLin::DimensionError){ NuLin.lls(a, b) }
+    assert_raise(NuLin::DimensionError){ NuLin.lls(a, b, algorithm: :svd) }
+  end
+end

data/tests/test_narray.rb

@@ -0,0 +1,100 @@
+require 'test-unit'
+require 'nulin'
+require 'complex'
+
+class TestNArray < Test::Unit::TestCase
+  def test_square_p
+    assert(NArray[[1, 2], [3, 4]].square?)
+    assert(NArray[[1.0]].square?)
+    assert(!NArray.float(3, 3, 3).square?)
+    assert(!NArray.float(2, 3).square?)
+  end
+
+  def test_column_vector
+    m = NMatrix.int(3, 3); m.indgen(0, 1)
+    assert_equal(m.column_vector(0), NVector[0, 3, 6])
+    m = NMatrix.int(3, 3, 3); m.indgen!
+    assert_equal(m.column_vector(0), NVector[[0, 3, 6], [9, 12, 15], [18, 21, 24]])
+  end
+
+  def test_row_vector
+    m = NMatrix.int(3, 3); m.indgen(0, 1)
+    assert_equal(m.row_vector(0), NVector[0, 1, 2])
+    m = NMatrix.int(3, 3, 3); m.indgen!
+    assert_equal(m.row_vector(0), NVector[[0, 1, 2], [9, 10, 11], [18, 19, 20]])
+  end
+
+  def test_adjoint
+    m = NMatrix.int(3, 3); m.indgen(0, 1)
+    assert_equal(NMatrix[[0, 3, 6], [1, 4, 7], [2, 5, 8]] , m.adjoint)
+    m = NMatrix[[Complex(1, 2), 0], [Complex(0, -2), Complex(-1, 4)]]
+    assert_equal(NMatrix[[Complex(1, -2), Complex(0, 2)], [0, Complex(-1, -4)]],
+                 m.adjoint)
+  end
+
+  def test_row_vectors
+    m = NMatrix.int(2, 3); m.indgen(0, 1)
+    assert_equal([NVector[0,1], NVector[2,3], NVector[4,5]], m.row_vectors)
+  end
+
+  def test_column_vectors
+    m = NMatrix.int(2, 3); m.indgen(0, 1)
+    assert_equal([NVector[0,2,4], NVector[1,3,5]], m.column_vectors)
+  end
+
+  def test_as_vector
+    assert_equal(NVector[1, 2], NMatrix[[1, 2]].as_vector)
+    assert_equal(NVector[1, 2], NMatrix[[1],[2]].as_vector)
+    assert_raise(ArgumentError){ NMatrix[[1,2],[3,4]].as_vector }
+  end
+  
+  def test_I
+    m = NMatrix.I(3)
+    assert_equal(NArray::DFLOAT, m.typecode)
+    assert_narray_in_delta(NMatrix[[1.0, 0.0, 0.0],
+                                   [0.0, 1.0, 0.0],
+                                   [0.0, 0.0, 1.0]], m)
+  end
+
+  def test_diagonal
+    diag = NVector[1.0, 2.0, 3.0]
+    m = NMatrix.diagonal(diag)
+    assert_equal(NArray::DFLOAT, m.typecode)
+    assert_narray_in_delta(NMatrix[[1.0, 0.0, 0.0],
+                                   [0.0, 2.0, 0.0],
+                                   [0.0, 0.0, 3.0]], m)
+  end
+
+  def test_build
+    m = NMatrix.build(NArray::DFLOAT, 2, 3){|m, n| m*4 + n }
+    assert_equal(NArray::DFLOAT, m.typecode)
+    assert_narray_in_delta(NMatrix[[0.0, 4.0],[1.0, 5.0], [2.0, 6.0]], m)
+  end
+
+  def test_each_with_index
+    m = NMatrix.build(NArray::INT, 2, 3){|m, n| (m + n*2)*2 }
+    r = []
+    m.each_with_index{|*k| r << k }
+    assert_equal([[0, 0, 0], [2, 1, 0],
+                  [4, 0, 1], [6, 1, 1],
+                  [8, 0, 2], [10, 1, 2]], r)
+                  
+  end
+
+  def test_filled
+    m = NArray.filled(NArray::FLOAT, 4.0, 2, 3)
+    assert_equal(NArray::FLOAT, m.typecode)
+    assert_equal([2, 3], m.shape)
+    m.each{|v| assert_equal(4.0, v) }
+  end
+
+  def test_norm
+    assert_in_delta(5.0, NVector[3.0, 4.0].norm)
+    assert_in_delta(5.0, NVector[3.i, 4].norm)
+  end
+  
+  def test_normalize
+    assert_narray_in_delta(NVector[3.0/5.0, 4.0/5.0],
+                           NVector[3.0, 4.0].normalize)
+  end
+end

data/tests/test_qr.rb

@@ -0,0 +1,56 @@
+require 'nulin'
+require 'test-unit'
+
+
+class TestNuLin_qr < Test::Unit::TestCase
+  def test_qr
+    m = NMatrix[[-0.8, 1.2, 0.9, 0.2],
+                [0.0, 0.3, -0.7, 0.4],
+                [0.1, -0.3, 0.7, -0.4],
+                [0.2, 0.4, -0.1, 0.5]]
+    check_qr_for(m, NArray::DFLOAT)
+    
+    sm = NMatrix.sfloat(4, 4); sm[] = m
+    check_qr_for(sm, NArray::SFLOAT)
+    
+    m = NMatrix[[-0.8, 1.2, 0.9, 0.2],
+                [0.0, 0.3, -0.7, 0.4],
+                [0.2, 0.4, -0.1, 0.5]]
+    check_qr_for(m, NArray::DFLOAT)
+
+    m = NMatrix[[-0.8, 1.2, 0.9],
+                [0.0, 0.3, -0.7],
+                [0.1, -0.3, 0.7],
+                [0.2, 0.4, -0.1]]
+    check_qr_for(m, NArray::DFLOAT)
+
+    re = NMatrix[[-0.8, 1.2, 0.9, 0.2],
+                 [0.0, 0.3, -0.7, 0.4],
+                 [0.1, -0.3, 0.7, -0.4],
+                 [0.2, 0.4, -0.1, 0.5]]
+    imag = NMatrix[[ 0.277778, 0.347718, 1.25833, 0.257209 ], 
+                   [ 0.159667, -0.0683527, 1.60072, 0.479529 ], 
+                   [ 0.537662, -1.08895, -0.815658, -0.247471 ], 
+                   [ -2.0635, 0.201613, 3.78139, -1.52979 ]]
+    m = NMatrix.complex(4, 4); m[] = re; m.imag = imag
+    check_qr_for(m, NArray::DCOMPLEX)
+
+    m = NMatrix.scomplex(4, 4); m[] = re; m.imag = imag
+    check_qr_for(m, NArray::SCOMPLEX)
+  end
+  
+  def check_qr_for(m, typecode)
+    qr = NuLin.qr(m)
+
+    assert_equal(typecode, qr.Q.typecode)
+    assert_equal(typecode, qr.R.typecode)
+    assert_narray_in_delta(NMatrix.I(qr.Q.shape[0], typecode), qr.Q * qr.Qt)
+    assert_narray_in_delta(m,  qr.Q * qr.R)
+    qr.R.each_with_index do |v, i, j|
+      if i < j
+        assert(v.abs < 0.0001)
+      end
+    end
+    assert(qr.Q.adjoint == qr.Qt)
+  end
+end

data/tests/test_svd.rb

@@ -0,0 +1,51 @@
+require 'test-unit'
+require 'nulin'
+
+class TestNuLin_svd < Test::Unit::TestCase
+  REAL_MATRIX = NMatrix[[1.2, 0.8, -1.9, 0.4],
+                        [0.0, -2.1, 0.2, -0.12],
+                        [-0.2, 0.48, 1.02, 0.09]]
+
+  COMPLEX_MATRIX = NMatrix[[Complex(1,2), Complex(3,4), Complex(5,6)],
+                           [Complex(7,8), Complex(9,10), Complex(11, 12)],
+                           [Complex(-6, -5), Complex(-4, -3), Complex(-2, -1)],
+                           [Complex(0,1), Complex(2,3), Complex(4,5)]]
+  def test_svd_dfloat
+    check_svd(REAL_MATRIX, 4, 3, NArray::FLOAT, NArray::FLOAT)
+  end
+
+  def test_svd_sfloat
+    m = NMatrix.sfloat(4, 3); m[] = REAL_MATRIX
+    check_svd(m, 4, 3, NArray::SFLOAT, NArray::SFLOAT)
+  end
+
+  def test_svd_dcomplex
+    check_svd(COMPLEX_MATRIX, 3, 4, NArray::DCOMPLEX, NArray::DFLOAT)
+  end
+
+  def test_svd_scomplex
+    m = NMatrix.scomplex(3, 4); m[] = COMPLEX_MATRIX
+    check_svd(m, 3, 4, NArray::SCOMPLEX, NArray::SFLOAT)
+  end
+  
+  def check_svd(matrix, rows, columns, typecode, sv_typecode)
+    assert_equal([rows, columns], matrix.shape)
+    
+    svd = NuLin.svd(matrix, full_matrix: true)
+
+    assert_equal([columns, columns], svd.U.shape)
+    assert_equal([rows, rows], svd.V.shape)
+    assert_equal([rows, rows], svd.Vt.shape)
+    assert_equal([rows, columns], svd.sigma.shape)
+    assert_equal([[columns,rows].min], svd.singular_values.shape)
+    assert_equal(typecode, svd.U.typecode)
+    assert_equal(typecode, svd.Vt.typecode)
+    assert_equal(sv_typecode, svd.singular_values.typecode)
+    assert_equal(typecode, svd.sigma.typecode)
+
+    assert_narray_in_delta(matrix, svd.U * svd.sigma * svd.V.transpose)
+    ([rows, columns].min - 1).times do |n|
+      assert(svd.singular_values[n] > svd.singular_values[n+1])
+    end
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: nulin
+version: !ruby/object:Gem::Version
+  version: '0.2'
+platform: ruby
+authors:
+- Ippei Obayashi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0.1
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  A linear algebra library cooperating with NArray.
+  This library calls blas and lapack routines for fast computations.
+  This library has following functionalities.
+
+  * xGEMM (multiply two matrices and add other matrix)
+  * Solve LLS(Least Square Sum) problems
+  * Computing determinant (using QR decomposition)
+  * Solve eigenproblems (compute eigenvalues and eigenvectors)
+  * (Pivoted) LU decompotision
+  * SVD(Singular value decomposition)
+  * QR decomposition
+  * Cholesky decomposition
+email: ohai@kmc.gr.jp
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- lib/narray_extext.rb
+- lib/nulin.rb
+- lib/nulin/qr.rb
+- lib/nulin/eigensystem.rb
+- lib/nulin/gemm.rb
+- lib/nulin/svd.rb
+- lib/nulin/cholesky.rb
+- lib/nulin/det.rb
+- lib/nulin/lls.rb
+- tests/run_test.rb
+- tests/test_det.rb
+- tests/test_narray.rb
+- tests/test_qr.rb
+- tests/test_gemm.rb
+- tests/test_svd.rb
+- tests/test_lls.rb
+- tests/test_cholesky.rb
+- tests/test_eigensystem.rb
+- doc/BSDL
+- doc/COPYING
+- doc/README.en
+- doc/README.ja
+- ext/extconf.rb
+- ext/nulin_native.c
+homepage: http://www.kmc.gr.jp/~ohai/nulin/
+licenses:
+- 2-clause BSDL
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Linear algebra library cooperating with NArray
+test_files: []