nulin 0.2

data/lib/nulin/lls.rb

@@ -0,0 +1,133 @@
+
+module NuLin
+  module_function
+  # Solve the linear least square problem
+  # of min_x |a*x - b|.
+  #
+  # The solution is returned as an instance of NuLin::LLS.
+  #
+  # When n >= m and rank(a) = n, the problem has a unique solution.
+  #
+  # When n < m and rank(a) = n, the equation a*x - b = 0 has
+  # infinitely many solutions. In this case, we consider the problem
+  # of finding the (unique) solution which minimizes |x|.
+  #
+  # If rank(a)=min(m, n), we can find the solution of the two
+  # problems using QR or LQ factorization.
+  #
+  # In the general case, if rank(a) < min(m, n), the above two problems
+  # don't have a unique solution. Therefore we consider the problem 
+  # of finding x which minimize |a*x-b| and |x|^2. We can solve the problem
+  # using complete orthogonal factorization or SVD.
+  #
+  # options
+  # * :algorithm (default :qr) - select algorithm :qr, :svd
+  # * :rcond (default -1.0) - The threshold to determine effective rank of
+  #   matrix a. This parameter is used only for svd algorithm.
+  #   The number of singular values greater than
+  #   rcond * (the largest singular value) is regarded as the effective rank.
+  #
+  # Example
+  # # Using QR/LQ algorithm
+  # x = NuLin.linear_least_square(a, b).solution
+  #
+  # # Using SVD
+  # x = NuLin.linear_least_square(a, b, algorithm: :svd, rcond: 0.0001).solution
+  #
+  # @param a[NMatrix] a matrix whose shape is [n, m]
+  # @param b[NVector] a vector whose shape is [m]
+  # @param options[Hash] computation options
+  def linear_least_square(a, b, options={})
+    case options.fetch(:algorithm, :qr)
+    when :qr
+      NuLin::LLS_QR.new(a, b, options)
+    when :svd
+      NuLin::LLS_SVD.new(a, b, options)
+    end
+  end
+
+  def lls(*args); linear_least_square(*args); end
+end
+
+class NuLin::LLS
+  def initialize(a, b, options)
+    if !valid_matrix?(a, b)
+      raise NuLin::DimensionError, "Invalid matrix/vector shape"
+    end
+    @a = a.transpose
+    @b_is_rank1 = b.rank == 1
+    @b = (@b_is_rank1) ? b.reshape(b.shape[0], 1) : b
+    
+    @typecode = a.typecode
+  end
+
+  def valid_matrix?(a, b)
+    a.rank == 2 &&
+      (b.rank == 1 || b.rank == 2) &&
+      a.shape[1] == b.shape[0] &&
+      a.typecode == b.typecode 
+  end
+
+  # Return the solution of the LLS problem as NVector.
+  attr_reader :solution
+end
+
+class NuLin::LLS_QR < NuLin::LLS
+  def initialize(a, b, options)
+    super
+    compute
+  end
+  
+  def compute
+    m, n = @a.shape
+    lda = m
+    ldb = [1, m, n].max
+    r, nrhs = @b.shape
+    b = NVector.new(@typecode, ldb, nrhs)
+    b[0...m, 0...nrhs] = @b
+    lwork = [1, [m,n].min + [[m,n].min, nrhs].max].max
+    work = NArray.new(@typecode, lwork)
+    NuLin::Native.call(@typecode, "gels", "N", m, n, nrhs, @a, lda, b, ldb,
+                       work, lwork, 0)
+    @solution = b[0...n, true]
+    @solution.flatten! if @b_is_rank1
+  end
+end
+
+class NuLin::LLS_SVD < NuLin::LLS
+  def initialize(a, b, options)
+    super
+    @rcond = options.fetch(:rcond, -1.0)
+    compute
+  end
+
+  # Singular values of the matrix as NArray.
+  # The values are ordered decreasingly.
+  attr_reader :singular_values
+  # The effective rank of the matrix.
+  attr_reader :rank
+  
+  def compute
+    m, n = @a.shape
+    r, nrhs = @b.shape
+    k = [m, n].min
+    lda = [1, m].max
+    ldb = [1, m, n].max
+    b = NVector.new(@typecode, ldb, nrhs)
+    b[0...m, 0...nrhs] = @b
+    s = NArray.new(NuLin.to_real_typecode(@typecode), k)
+    lwork = 3*k + [2*k, m, n, nrhs].max + 1
+    work = NVector.new(@typecode, lwork)
+    if @a.complex?
+      rwork = [NArray.new(@typecode, 5*k)]
+    else
+      rwork = []
+    end
+    @rank, = NuLin::Native.call(@typecode, "gelss", m, n, nrhs, @a, lda, b, ldb, s,
+                                @rcond, 0, work, lwork, *rwork, 0)
+    
+    @singular_values = s
+    @solution = b[0...n, true]
+    @solution.flatten! if @b_is_rank1
+  end
+end

data/lib/nulin/qr.rb

@@ -0,0 +1,68 @@
+
+module NuLin
+  module_function
+  # Compute the QR Decomposition of `matrix`
+  # and return the result as NuLin::QR object.
+  #
+  # You can call this with `options`, but now the argument is 
+  # ignored.
+  #
+  # @param matrix[NMatrix] The matrix
+  # @param options[Hash] computation options, not used now.
+  def qr(matrix, options={})
+    NuLin::QR.new(matrix, options)
+  end
+end
+
+class NuLin::QR
+  def initialize(matrix, options)
+    @matrix = matrix
+    @typecode = matrix.typecode
+
+    compute
+  end
+
+  # The orthgonal/unitary matrix Q
+  attr_reader :Q
+  # The tranposed/adjoint matrix of Q
+  attr_reader :Qt
+  # The upper triangular matrix R
+  attr_reader :R
+  
+  private
+  def compute
+    m, n = @matrix.shape
+    lwork = n
+    
+    q = base_q
+    tau = NArray.new(@typecode, n)
+    work = NArray.new(@typecode, lwork)
+
+    NuLin::Native.call(@typecode, "gelqf", n, n, q, n, tau, work, lwork, 0)
+    NuLin::Native.call(@typecode, glq_name, n, n, n, q, n, tau, work, lwork, 0)
+
+    @Q = q
+    @Qt = q.adjoint
+    @R = @Qt * @matrix
+  end
+
+  def glq_name
+    if NArray.complex_typecode?(@typecode)
+      "unglq"
+    else
+      "orglq"
+    end
+  end
+  
+  def base_q
+    m, n = @matrix.shape
+    case
+    when m >= n
+      @matrix[0...n, 0...n]
+    when m < n
+      bq = NMatrix.new(@typecode, n, n)
+      bq[0...m, 0...n] = @matrix
+      bq
+    end
+  end
+end

data/lib/nulin/svd.rb

@@ -0,0 +1,84 @@
+
+module NuLin
+  module_function
+  # Compute the Singular Value Decomposition of `matrix`
+  # and return the result as an instance of SVD
+  #
+  # You can call this with some `options` as follows
+  #   * :use_U (default true) Compute the matrix U
+  #   * :use_V (default true) Compute the matrix V and V^t
+  #   * :full_matrix (default true)
+  # From the theory of SVD,
+  # Any matrix is decomposable into U * sigma * transpose(V)
+  # where
+  #   * U, V: orthogonal(real) or unitary(complex) matrices
+  #   * sigma: diagonal matrix
+  #
+  # @param matrix[NMatrix] target matrix
+  # @param options[Hash] computation options
+  def svd(matrix, options={})
+    SVD.new(matrix, options)
+  end
+end
+
+class NuLin::SVD
+  def initialize(matrix, opts)
+    @matrix = matrix
+    @use_U = opts.fetch(:use_U, true)
+    @use_V = opts.fetch(:use_V, true)
+    @full_matrix = opts.fetch(:full_matrix, true)
+    @typecode = matrix.typecode
+    
+    compute
+  end
+
+  # The matrix U
+  attr_reader :U
+  # Transposed matrix of the matrix V
+  attr_reader :Vt
+  # Singular values as NArray object
+  attr_reader :singular_values
+  # The matrix V
+  def V
+    return nil unless @use_V
+    @V ||= @Vt.transpose
+  end
+  # The matrix sigma
+  def sigma
+    return @sigma if @sigma
+    @sigma = NMatrix.new(@matrix.typecode, *@matrix.shape)
+    @sigma.diagonal!(@singular_values.refer)
+  end
+  
+  private
+  def compute
+    m, n = @matrix.shape
+    k = [m, n].min
+    l = [m, n].max
+    s = NArray.new(NuLin.to_real_typecode(@typecode), k)
+    ldu = @use_V ? m : 1
+    u = NMatrix.new(@typecode, ldu, @use_V ? (@full_matrix ? m : k) : 0)
+    ldvt = @use_U ? (@full_matrix ? n : k) : 1
+    vt = NMatrix.new(@typecode, ldvt, @use_V ? n : 1)
+    # MAX(1,3*MIN(M,N)+MAX(M,N),5*MIN(M,N)) for real
+    # MAX(1,2*MIN(M,N)+MAX(M,N)) for complx
+    lwork = @matrix.real? ? [1, 3*k+l, 5*k].max : [1, 2*k + l].max
+    work = NArray.new(@typecode, lwork)
+    if @matrix.complex?
+      rwork = [NArray.new(@typecode, 5*k)]
+    else
+      rwork = []
+    end
+    
+    NuLin::Native.call(@typecode, "gesvd", job_str(@use_V), job_str(@use_U),
+                        m, n, @matrix.dup, m, s, u, ldu, vt, ldvt,
+                        work, lwork, *rwork, 0)
+    @U = vt if @use_U
+    @Vt = u if @use_V
+    @singular_values = s
+  end
+  
+  def job_str(using)
+    using ? (@full_matrix ? "A" : "S") : "N"
+  end
+end

data/tests/run_test.rb

@@ -0,0 +1,17 @@
+require 'test-unit'
+
+module Test::Unit::Assertions
+  eval <<-EOS
+  def assert_narray_in_delta(expected, actual, delta=0.001, message=nil)
+    failure_message = build_message(message, <<-EOT, expected, delta, actual)
+<?> +-? expected but was
+<?>
+    EOT
+    assert_block(failure_message) do
+      ((expected - actual).abs < delta).all?
+    end
+  end
+  EOS
+end
+
+exit Test::Unit::AutoRunner.run(true, ".")

data/tests/test_cholesky.rb

@@ -0,0 +1,39 @@
+require 'test-unit'
+require 'nulin'
+require 'complex'
+
+class TestNuLin_cholesky < Test::Unit::TestCase
+  def test_cholesky
+    m = NMatrix[ [ 1.18327, -0.484033, -0.675672, -1.33157 ], 
+                 [ -0.484033, 1.3897, 0.302005, 1.14085 ], 
+                 [ -0.675672, 0.302005, 0.964183, 0.61185 ], 
+                 [ -1.33157, 1.14085, 0.61185, 1.84453 ] ]
+    u = NuLin.cholesky(m, type: :U)
+    assert_narray_in_delta(m, u.transpose * u)
+    u.each_with_index do |v, i, j|
+      assert_in_delta(0.0, v) if i < j
+    end
+
+    l = NuLin.cholesky(m, type: :L)
+    assert_narray_in_delta(m, l * l.transpose)
+    l.each_with_index do |v, i, j|
+      assert_in_delta(0.0, v) if i > j
+    end
+
+    m = NMatrix[ [ 5.4452+0.0.i, 1.53215-1.46758.i, 3.47221+1.94952.i ], 
+                 [ 1.53215+1.46758.i, 8.51107+0.0.i, -5.64531+1.63224.i ], 
+                 [ 3.47221-1.94952.i, -5.64531-1.63224.i, 8.67626+0.0.i ] ]
+
+    u = NuLin.cholesky(m, type: :U)
+    assert_narray_in_delta(m, u.adjoint * u)
+    u.each_with_index do |v, i, j|
+      assert_in_delta(0.0, v.abs) if i < j
+    end
+
+    l = NuLin.cholesky(m, type: :L)
+    assert_narray_in_delta(m, l * l.adjoint)
+    l.each_with_index do |v, i, j|
+      assert_in_delta(0.0, v.abs) if i > j
+    end
+  end
+end

data/tests/test_det.rb

@@ -0,0 +1,11 @@
+require 'test-unit'
+require 'nulin'
+
+class TestNuLin_det < Test::Unit::TestCase
+  def test_det
+    m = NMatrix[[1.0, 0.8, -0.1],
+                [-0.4, 0.3, 1.2],
+                [-0.8, -0.3, -0.6]]
+    assert_in_delta(-0.816, NuLin.det(m))
+  end
+end

data/tests/test_eigensystem.rb

@@ -0,0 +1,71 @@
+require 'test-unit'
+require 'nulin'
+
+class TestNuLin_eigensystem < Test::Unit::TestCase
+  def test_eigensystem
+    m = NMatrix[[1.2, -4.2, 2.9],
+                [0.92, 1.5, 3.0],
+                [1.0, -0.5, -2.2]]
+
+    check_eigensystem(m, NArray::COMPLEX)
+  end
+
+  def test_for_real_eigensystem
+    m = NMatrix[[6.0, -3,  -7],
+                [ -1,  2,   1],
+                [  5, -3,  -6]]
+    eig = NuLin.eigensystem(m, use_complex: false)
+    
+    assert_equal(3, eig.dim)
+    assert_equal(NArray::FLOAT, eig.eigenvalues.typecode)
+    assert_equal(NArray::FLOAT, eig.right.typecode)
+    assert_equal(NArray::FLOAT, eig.left.typecode)
+  end
+
+  def test_eigensystem_sfloat
+    m = NMatrix[[1.2, -4.2, 2.9],
+                [0.92, 1.5, 3.0],
+                [1.0, -0.5, -2.2]]
+    md = NMatrix.sfloat(3, 3)
+    md[] = m
+
+    check_eigensystem(md, NArray::SCOMPLEX)
+  end
+
+  def test_eigensystem_complex
+    m = NMatrix[[Complex(1.2, 0.5), Complex(-3.8, -0.9), Complex(1.8)],
+                [Complex(0, -2.3), Complex(1.5, 1.0), Complex(1.2, 1.2)],
+                [Complex(-1.9, 0.1), Complex(0.0), Complex(-4.7, 0.7)]]
+    check_eigensystem(m, NArray::COMPLEX)
+  end
+
+  def test_eigensystem_scomplex
+    m = NMatrix[[Complex(1.2, 0.5), Complex(-3.8, -0.9), Complex(1.8)],
+                [Complex(0, -2.3), Complex(1.5, 1.0), Complex(1.2, 1.2)],
+                [Complex(-1.9, 0.1), Complex(0.0), Complex(-4.7, 0.7)]]
+    md = NMatrix.scomplex(3, 3); md[] = m
+    
+    check_eigensystem(md, NArray::SCOMPLEX)
+  end
+  
+  def check_eigensystem(m, typecode)
+    eig = NuLin.eigensystem(m)
+    
+    assert_equal(3, eig.dim)
+    assert_equal(typecode, eig.eigenvalues.typecode)
+    assert_equal(typecode, eig.right.typecode)
+    assert_equal(typecode, eig.left.typecode)
+    
+    eig.dim.times do |i|
+      v1 = m * eig.right.column_vector(i)
+      v2 = eig.eigenvalues[i] * eig.right.column_vector(i)
+      assert_narray_in_delta(v1, v2)
+      assert_equal(eig.right.column_vector(i), eig.right_eigenvectors[i])
+      
+      w1 = eig.left.row_vector(i) * m
+      w2 = eig.left.row_vector(i) *  eig.eigenvalues[i]
+      assert_narray_in_delta(w1, w2)
+      assert_equal(eig.left.row_vector(i), eig.left_eigenvectors[i])
+    end
+  end
+end

data/tests/test_gemm.rb

@@ -0,0 +1,57 @@
+require 'nulin'
+
+require 'test-unit'
+
+class TestNuLin_mm < Test::Unit::TestCase
+  def test_mm
+    alpha = 1.4; beta = 0.75
+    a = NMatrix[[0.2, 0, -1.3],
+                [3.1, 0.92, -1.2],
+                [-0.9, 1.0, 0.0],
+                [-1.2, 1.1, 3.1]]
+    b = NMatrix[[0.2, 0.3, -0.123, -0.01, 0.02],
+                [0.32, 0.2, 0.11, -0.12, 1.22],
+                [0.2, 1.2, -0.3, 0.4, 1.1]]
+    c = NMatrix[ [ -0.809611, 0.308441, 0.178653, 0.14375, 1.51829 ], 
+                 [ -0.438721, -2.22648, 1.19524, -0.767709, 0.0279701 ], 
+                 [ -0.522194, 0.807863, -0.39172, -0.679458, -0.534994 ], 
+                 [ -0.0155417, -1.34528, -1.08651, -0.686664, 1.044 ] ]
+    
+    assert_narray_in_delta(alpha*a*b + beta*c, NuLin.mm(alpha, a, b, beta, c))
+
+    a = a.to_type(NArray::SFLOAT)
+    b = b.to_type(NArray::SFLOAT)
+    c = c.to_type(NArray::SFLOAT)
+
+    assert_narray_in_delta(alpha*a*b + beta*c, NuLin.mm(alpha, a, b, beta, c))
+
+    alpha = 1.4 + 1.2.i; beta = 0.75 - 0.4.i
+    
+    a = NMatrix[ [ 0.125503+0.180057.i, -0.567269+1.70667.i, -1.15548+1.95302.i ], 
+                 [ 0.59267+0.828465.i, 0.46672-0.0995614.i, -0.635015-1.14206.i ], 
+                 [ 0.330225+0.122008.i, -0.932912-2.2586.i, -0.13695+1.22169.i ], 
+                 [ -0.324652+0.629844.i, -0.276656-0.148201.i, -0.919279-1.76697.i ] ]
+    b = NMatrix[ [-0.547 + 0.251.i, -0.202 + 0.206.i, 1.635 + -0.312.i, -0.463 + -0.604.i,  -0.440 + 1.257.i],
+                 [-0.250 + 0.333.i, -0.220 + 0.140.i, 0.226 + -0.006.i, 1.392 + -0.191.i, 1.113 + 0.915.i],
+                 [0.564 + -1.962.i, -0.988 + -0.074.i, 0.395 + -1.089.i, 0.445 + 0.741.i, 0.879 + -1.495.i]]
+
+    c = NMatrix[ [-1.192 + 0.398.i,0.595 + -0.781.i,-0.936 + -2.004.i,-1.110 + -0.091.i,-1.176 + -1.259.i,],
+                 [-0.612 + -0.267.i,-0.704 + 2.284.i,-0.816 + -1.802.i,-0.621 + 0.207.i,0.858 + 0.094.i,],
+                 [0.185 + 0.021.i,-0.935 + -0.658.i,1.179 + 2.649.i,1.018 + -1.135.i,0.532 + -0.287.i,],
+                 [1.378 + 0.254.i,1.047 + 0.024.i,-1.637 + 1.171.i,0.864 + 1.070.i,2.015 + -0.231.i,]]
+
+    assert_narray_in_delta(alpha*a*b + beta*c, NuLin.mm(alpha, a, b, beta, c))
+    assert_narray_in_delta(alpha*a*b + beta*c,
+                           NuLin.mm(alpha, a.transpose, b, beta, c, trans_a: :transpose))
+    assert_narray_in_delta(alpha*a*b + beta*c,
+                           NuLin.mm(alpha, a.adjoint, b, beta, c, trans_a: :adjoint))
+    assert_narray_in_delta(alpha*a*b + beta*c,
+                           NuLin.mm(alpha, a.transpose, b.adjoint, beta, c,
+                                    trans_a: :transpose, trans_b: :adjoint))
+    a = a.to_type(NArray::SCOMPLEX)
+    b = b.to_type(NArray::SCOMPLEX)
+    c = c.to_type(NArray::SCOMPLEX)
+
+    assert_narray_in_delta(alpha*a*b + beta*c, NuLin.mm(alpha, a, b, beta, c))
+  end
+end