nulin 0.2

data/lib/narray_extext.rb

@@ -0,0 +1,113 @@
+require 'narray'
+
+class NArray
+  def square?
+    shape = self.shape
+    rank == 2 && shape[0] == shape[1]
+  end
+
+  def real?
+    typecode == DFLOAT || typecode == SFLOAT
+  end
+
+  def self.build(typecode, *sizes)
+    nary = new(typecode, *sizes)
+    (0 ... nary.size).each{|i| nary[i] = yield(*nary.ndindex_from_1dindex(i)) }
+    nary
+  end
+  
+  def ndindex_from_1dindex(i)
+    ret = []
+    shape.each{|n| ret << i%n; i /= n }
+    ret
+  end
+
+  def each_with_index
+    (0 ... size).each{|i| yield(self[i], *ndindex_from_1dindex(i)) }
+  end
+
+  def self.complex_typecode?(typecode)
+    typecode == NArray::DCOMPLEX || typecode == NArray::SCOMPLEX
+  end
+
+  def self.filled(typecode, data, *sizes)
+    naray = new(typecode, *sizes)
+    naray.fill(data)
+    naray
+  end
+end
+
+class NMatrix
+  def row_vector(i)
+    NVector.ref(NArray.ref(self)[true, i, false])
+  end
+
+  def row_vectors
+    d = self.shape[1]
+    (0 ... d).map{|i| row_vector(i) }
+  end
+  
+  def column_vector(i)
+    NVector.ref(NArray.ref(self)[i, false])
+  end
+
+  def column_vectors
+    d = self.shape[0]
+    (0 ... d).map{|i| column_vector(i) }
+  end
+  
+  def adjoint
+    ret = self.transpose; ret.conj!
+    ret
+  end
+
+  def as_vector
+    if rank != 2 || (shape[0] != 1 && shape[1] != 1)
+      raise(ArgumentError,
+            "NMatrix#as_vector: the matrix should be column matrix" +
+            "or row matrix")
+    end
+    
+    NVector.ref(flatten)
+  end
+  
+  def self.diagonal(a, shape=[a.size, a.size], typecode=nil)
+    typecode ||= array2typecode(a)
+    m = NMatrix.new(typecode, *shape)
+    a = a.refer if a.kind_of?(NArray)
+    m.diagonal!(a)
+    
+    m
+  end
+
+  def self.array2typecode(ary)
+    if ary.kind_of?(NArray)
+      ary.typecode
+    else
+      case ary[0]
+      when Float then NArray::DFLOAT
+      when Integer then NArray::INT
+      when Complex then NArray::DCOMPLEX
+      else NArray::OBJECT
+      end
+    end
+  end
+
+  def self.I(n, typecode=NArray::DFLOAT)
+    m = NMatrix.new(typecode, n, n)
+    m.I
+
+    m
+  end
+
+end
+
+class NVector
+  def normalize
+    self / norm
+  end
+
+  def norm
+    Math.sqrt(self.mul_add(self.conjugate, 0).real)
+  end
+end

data/lib/nulin.rb

@@ -0,0 +1,51 @@
+require 'narray'
+require 'narray_extext'
+require 'singleton'
+require 'nulin_native'
+
+module NuLin
+  class DimensionError < StandardError
+  end
+
+  class LinalgError < StandardError
+  end
+
+  TYPECODES = [NArray::SFLOAT, NArray::DFLOAT, NArray::SCOMPLEX, NArray::DCOMPLEX]
+  
+  LAPACK_PREFIX = {
+    NArray::SFLOAT => "s", NArray::DFLOAT => "d",
+    NArray::SCOMPLEX => "c", NArray::DCOMPLEX => "z",
+  }
+
+  module_function
+  def to_real_typecode(typecode)
+    return NArray::DFLOAT if typecode == NArray::DCOMPLEX
+    return NArray::SFLOAT if typecode == NArray::SCOMPLEX
+    return typecode
+  end
+
+  def to_complex_typecode(typecode)
+    return NArray::SCOMPLEX if typecode == NArray::SFLOAT
+    return NArray::DCOMPLEX 
+  end
+  
+  module Native
+    module_function
+    def call(typecode, name, *args)
+      fun_name = LAPACK_PREFIX[typecode] + name
+      retvals = __send__(fun_name, *args)
+      info = retvals ? retvals.last : 0
+      raise LinalgError, "#{fun_name}: errno #{info}" if info != 0
+
+      return retvals
+    end
+  end
+end
+
+require 'nulin/eigensystem'
+require 'nulin/svd'
+require 'nulin/lls'
+require 'nulin/qr'
+require 'nulin/det'
+require 'nulin/cholesky'
+require 'nulin/gemm'

data/lib/nulin/cholesky.rb

@@ -0,0 +1,62 @@
+module NuLin
+  module_function
+  # Compute the Cholesky decomposition for a positive definite
+  # symmetric/Hermitian `matrix`.
+  #
+  # Options
+  # * :type (default :U) - select whether the result matrix
+  #   is upper(:U) or lower(:L).
+  #
+  # If the matrix is not positive definite, NuLin::LinalgError is raised.
+  #
+  # @note This method doesn't validate the matrix is symmetric/Hermitian.
+  #       The only upper/lower half of the matrix is used for the computation.
+  # @param matrix[NMatrix] target matrix
+  # @param options[Hash] option hash
+  def cholesky(matrix, options={})
+    unless matrix.square?
+      raise DimensionError, "Cholesky decomposition is computable for a square matrix"
+    end
+
+    return Cholesky.new(matrix, options).result
+  end
+end
+
+class NuLin::Cholesky
+  def initialize(matrix, options)
+    @a = matrix
+    @typecode = matrix.typecode
+    case options.fetch(:type, :U)
+    when :U then @upper_triangular = true
+    when :L then @upper_triangular = false
+    else raise ArgumentError, "NuLin.cholesky: :type argument should be :U or :L"
+    end
+    compute
+  end
+
+  attr_reader :result
+  
+  def compute
+    n, = @a.shape
+    @result = @a.transpose
+    NuLin::Native.call(@typecode, "potrf", @upper_triangular ? "L" : "U",
+                       n, @result, n, 0)
+    if @upper_triangular
+      clear_lower
+    else
+      clear_upper
+    end
+
+    @result.conj!
+  end
+
+  def clear_lower
+    n, = @result.shape
+    0.upto(n-1){|i| (i+1).upto(n-1){|j| @result[i, j] = 0.0 } }
+  end
+
+  def clear_upper
+    n, = @result.shape
+    0.upto(n-1){|i| (i+1).upto(n-1){|j| @result[j, i] = 0.0 } }
+  end
+end

data/lib/nulin/det.rb

@@ -0,0 +1,17 @@
+module NuLin
+  module_function
+  # Compute the determinant of the `matrix` and return it.
+  #
+  # You get an exception NuLin::DimensionError if the matrix is not square
+  # The determinant of given matrix is computed using QR factorization.
+  #
+  # @param matrix[NMatrix] target matrix
+  def det(matrix)
+    unless matrix.square?
+      raise DimensionError, "Determinant is computable only on a square matrix"
+    end
+    n, = matrix.shape
+    r = qr(matrix).R
+    (0 ... n).inject(1.0){|u, i| u*r[i,i] }
+  end
+end

data/lib/nulin/eigensystem.rb

@@ -0,0 +1,191 @@
+
+module NuLin
+  module_function
+  
+  # Return the eigensystem(a pair of eigenvalues and left/right eigenvectors)
+  # of `matrix` as an instance of (a subclass of) EigenDecomposition
+  #
+  # You can call this with some `options` as follows
+  #   * :use_complex (default true) Return complex NArray objects
+  #     If you enable this, the return object (EigenDecomposition)
+  #     holds complex NArray objects.
+  #     If you disable this, it is assumed that all eigenvalues are
+  #     real and the return object holds the real NArray objects.
+  #     If you disable this but there is a complex eigenvalue,
+  #     the exception ArgumentError is raised.
+  #     This options is ignored if `matrix` is complex.
+  #   * :use_right (default true) - Compute right eigenvectors
+  #   * :use_left (default true) - Compute left eigenvectors
+  # @param matrix [NMatrix] target matrix
+  # @param options [Hash] options
+  def eigensystem(matrix, options={})
+    unless matrix.square?
+      raise DimensionError, "The eigensystem is computable only for a square matrix"
+    end
+    
+    case
+    when matrix.real?
+      RealEigenDecomposition.new(matrix, options)
+    when matrix.complex?
+      ComplexEigenDecomposition.new(matrix, options)
+    else
+      raise ArgumentError, "The eigensystem is comptable for a complex/float matrix"
+    end
+  end
+
+  class EigenDecomposition
+    # Dimension of the linear space
+    attr_reader :dim
+    # All eigenvalues as NArray object
+    attr_reader :eigenvalues
+    # Left eigenvectors as NMatrix
+    attr_reader :left
+    # Right eigenvectors as NMatrix
+    attr_reader :right
+
+    # Returns all right eigenvectors as the array of NVector
+    def right_eigenvectors
+      @right_eigenvectors ||= @right.column_vectors
+    end
+
+    # Returns all right eigenvectors as the array of NVector
+    def left_eigenvectors
+      @left_eigenvectors ||= @left.row_vectors
+    end
+  end
+  
+  class RealEigenDecomposition < EigenDecomposition
+    def initialize(matrix, opts)
+      @matrix = matrix
+      @dim = matrix.shape[0]
+      @use_left = opts.fetch(:use_left, true)
+      @use_right = opts.fetch(:use_right, true)
+      @use_complex = opts.fetch(:use_complex, true)
+      @typecode = matrix.typecode
+      @complex_typecode = NuLin.to_complex_typecode(@typecode)
+      
+      compute
+    end
+    
+    private
+    def compute
+      n, = @matrix.shape
+      @wr = NArray.new(@typecode, n)
+      @wi = NArray.new(@typecode, n)
+      ldvl = @use_right ? n : 1
+      @vl = NArray.new(@typecode, ldvl, n)
+      ldvr = @use_left ? n : 1
+      @vr = NArray.new(@typecode, ldvr, n)
+      lwork = (@use_left || @use_right) ? 4*n : 3*n
+      work = NArray.new(@typecode, lwork)
+
+      NuLin::Native.call(@typecode, "geev",
+                         @use_right ? 'V' : 'N', @use_left ? 'V' : 'N',
+                         n, @matrix.dup, n, @wr, @wi, @vl, ldvl, @vr, ldvr,
+                         work, lwork, 0)
+
+      if !@use_complex && !@wi.eq(0.0).all?
+        raise ArgumentError, "There is any complex eigenvalue"
+      end
+      compute_eigenvalues
+      compute_right if @use_right
+      compute_left if @use_left
+    end
+    
+    def compute_eigenvalues
+      @eigenvalues = @use_complex ? complex_eigenvalues : real_eigenvalues
+    end
+
+    def real_eigenvalues
+      @wr
+    end
+    
+    def complex_eigenvalues
+      eigenvalues = NArray.new(@complex_typecode, @dim)
+      eigenvalues[] = @wr
+      eigenvalues.imag = @wi
+      eigenvalues
+    end
+    
+    # compute right eigenvectors and right eigenvector matrix
+    def compute_right
+      unless @use_complex
+        @right = NMatrix.ref(@vl).transpose
+        return
+      end
+
+      @right_eigenvectors = extract_complex_eigenvectors(@vl, -1)
+      @right = NMatrix.new(@complex_typecode, @dim, @dim)
+      @right_eigenvectors.map.with_index do |v, i|
+        @right[i, true] = v
+      end
+    end
+
+    # Extract eigenvectors from the result(vl or vr) of NumRu::Lapack.dgeev
+    def extract_complex_eigenvectors(m, sign)
+      eigenvectors = []
+      (0 ... @dim).each do |i|
+        if @wi[i] == 0.0
+          eigenvectors << NVector.ref(m[true, i])
+        elsif @wi[i] > 0.0
+          v = NVector.new(@complex_typecode, @dim)
+          v[] = m[true, i]; v.imag = m[true, i+1]
+          v.conj! if sign < 0
+          eigenvectors << v
+        else
+          eigenvectors << eigenvectors.last.conj
+        end
+      end
+
+      eigenvectors
+    end
+
+    # compute left eigenvectors and left eigenvector matrix
+    def compute_left
+      unless @use_complex
+        @left = NMatrix.ref(@vr)
+        return
+      end
+
+      @left_eigenvectors = extract_complex_eigenvectors(@vr, 1)
+      @left = NMatrix.new(@complex_typecode, @dim, @dim)
+      @left_eigenvectors.map.with_index do |v, i|
+        @left[true, i] = v
+      end
+    end
+  end
+
+  class ComplexEigenDecomposition < EigenDecomposition
+    def initialize(matrix, opts)
+      @matrix = matrix
+      @dim = matrix.shape[0]
+      @use_left = opts.fetch(:use_left, true)
+      @use_right = opts.fetch(:use_right, true)
+      @typecode = matrix.typecode
+      
+      compute
+    end
+    
+    private
+    # TODO: @left should be adjoint or not?
+    def compute
+      n, = @matrix.shape
+      @eigenvalues = NArray.new(@typecode, n)
+      ldvl = @use_right ? n : 1
+      vl = NMatrix.new(@typecode, ldvl, n)
+      ldvr = @use_left ? n : 1
+      vr = NMatrix.new(@typecode, ldvr, n)
+      lwork = 2*n
+      work = NArray.new(@typecode, lwork)
+      rwork = NArray.new(@typecode, 2*n)
+
+      NuLin::Native.call(@typecode, "geev",
+                         @use_right ? 'V' : 'N', @use_left ? 'V' : 'N',
+                         n, @matrix.dup, n, @eigenvalues,
+                         vl, ldvl, vr, ldvr, work, lwork, rwork, 0)
+
+      @right = vl.adjoint
+      @left = vr
+    end
+  end
+end

data/lib/nulin/gemm.rb

@@ -0,0 +1,53 @@
+module NuLin
+  module_function
+
+  # Return alpha*a*b + beta*c
+  def multiply_matrix_and_add(alpha, a, b, beta, c, options={})
+    c = c.dup if options.fetch(:overwrite_c, false)
+    trans_a = options.fetch(:trans_a, nil)
+    trans_b = options.fetch(:trans_b, nil)
+
+    if !trans_a
+      k, n = a.shape
+    else
+      n, k = a.shape
+    end
+    lda = a.shape[0]
+
+    if !trans_b
+      m, kk = b.shape
+    else
+      kk, m = b.shape
+    end
+    ldb = b.shape[0]
+
+    mm, nn = c.shape
+    ldc = mm
+    
+    unless k == kk && m == mm && n == nn
+      raise DimensionError, "Invalid matrix shape"
+    end
+    
+    NuLin::Native.call(a.typecode, "gemm",
+                       mm_transpose_character(trans_b), mm_transpose_character(trans_a),
+                       m, n, k, alpha, b, ldb, a, lda, beta, c, ldc)
+
+    c
+  end
+
+  def mm_transpose_character(t)
+    case t
+    when nil, false
+      "N"
+    when :T, :transpose
+      "T"
+    when :C, :H, :adjoint
+      "C"
+    else
+      raise ArgumentError, "Unkdnown transposing spec: #{t.inspect}"
+    end
+  end
+  
+  alias mm multiply_matrix_and_add
+  module_function :mm
+end