linalg 1.0.2

data/lib/linalg/dmatrix.rb

@@ -0,0 +1,29 @@
+#
+# Copyright (c) 2004-2008 by James M. Lawrence
+#
+# See LICENSE
+#
+
+require 'linalg'
+
+require 'linalg/exception'
+require 'linalg/math'
+require 'linalg/iterators'
+require 'linalg/xdata'
+
+require 'linalg/dmatrix/main'
+require 'linalg/dmatrix/qr'
+require 'linalg/dmatrix/cholesky'
+require 'linalg/dmatrix/fit'
+require 'linalg/dmatrix/schur'
+require 'linalg/dmatrix/svd'
+require 'linalg/dmatrix/lu'
+require 'linalg/dmatrix/cond'
+require 'linalg/dmatrix/nullspace'
+require 'linalg/dmatrix/solve'
+require 'linalg/dmatrix/eigen'
+require 'linalg/dmatrix/inverse'
+require 'linalg/dmatrix/norms'
+require 'linalg/dmatrix/det'
+require 'linalg/dmatrix/alias'
+

data/lib/linalg/dmatrix/alias.rb

@@ -0,0 +1,32 @@
+#
+# Copyright (c) 2004-2008 by James M. Lawrence
+#
+# See LICENSE
+#
+
+module Linalg
+   class DMatrix
+      alias_method :mul!, :postmul!
+      alias_method :t, :transpose
+      alias_method :inv, :inverse
+      alias_method :det, :determinant
+      alias_method :col, :column
+      alias_method :svd, :singular_value_decomposition
+      alias_method :sv, :singular_values
+      alias_method :chol, :cholesky
+      alias_method :nrow, :vsize
+      alias_method :num_rows, :vsize
+      alias_method :ncol, :hsize
+      alias_method :num_columns, :hsize
+      alias_method :pinv, :pseudo_inverse
+      alias_method :orth, :rankspace
+      alias_method :norm, :norm_2
+      alias_method :column_norm, :norm_1
+      alias_method :row_norm, :norm_inf
+      alias_method :frobenius_norm, :norm_f
+
+      private :symmetric_private
+   end
+end
+
+

data/lib/linalg/dmatrix/cholesky.rb

@@ -0,0 +1,52 @@
+#
+# Copyright (c) 2004-2008 by James M. Lawrence
+#
+# See LICENSE
+#
+
+
+module Linalg
+   class DMatrix
+      #
+      # call-seq:
+      #   cholesky  => u
+      #   cholesky { |u| ... }  => block result
+      #
+      # Given a symmetric positive definite matrix +m+, gives
+      # an upper-triangular matrix +u+ such that
+      #   u.t * u
+      # is equal to +m+.
+      #
+      # Only the upper-triangular portion of +m+ is considered
+      # for the algorithm.
+      #
+      # Raises +Diverged+ if +m+ was not positive definite.
+      #
+      def cholesky   # :yields: u
+         raise DimensionError unless square?
+         uplo = Char.new "U"
+         n = XInteger.new vsize
+         a = self.clone
+         lda = n
+         info = XInteger.new
+         
+         Lapack.dpotrf(uplo,
+                       n,
+                       a,
+                       lda,
+                       info)
+
+         raise Diverged unless info.value == 0
+         
+         a.zero_lower
+         
+         if block_given?
+            yield a
+         else
+            a
+         end
+      end
+   end
+end
+
+

data/lib/linalg/dmatrix/cond.rb

@@ -0,0 +1,80 @@
+#
+# Copyright (c) 2004-2008 by James M. Lawrence
+#
+# See LICENSE
+#
+
+
+module Linalg
+   class DMatrix
+      #
+      # The condition number.  Ratio of the largest singular value to
+      # the smallest.
+      #
+      def cond
+         s = singular_values
+         begin
+            c = s[0]/s[s.vsize-1]
+            c.nan? ? 1.0/0.0 : c
+         rescue SingularMatrix
+            1.0/0.0
+         end
+      end
+
+      #
+      # Estimate the condition number using the
+      # 1-norm.  Seems to be within an order of magnitude.
+      #
+      def cond_est_1
+         begin
+            1.0/rcond_private(:col)
+         rescue SingularMatrix
+            1.0/0.0
+         end
+      end
+
+      #
+      # Estimate the condition number using the
+      # infinity-norm.  Seems to be within an order of magnitude.
+      #
+      def cond_est_inf
+         begin
+            1.0/rcond_private(:row)
+         rescue SingularMatrix
+            1.0/0.0
+         end
+      end
+      
+      private
+
+      def rcond_private(which)
+         raise DimensionError unless square?
+
+         norm = (which == :col) ? Char.new("1") : Char.new("I")
+         n = XInteger.new vsize
+         a = self.clone
+         a.lu!
+         lda = n
+         anorm = DData.new(1) {
+            (which == :col) ? a.column_norm : a.row_norm
+         }
+         rcond = DReal.new
+         work = DData.new(4*n.value)
+         iwork = IData.new(n.value)
+         info = XInteger.new
+         
+         Lapack.dgecon(norm,
+                       n,
+                       a,
+                       lda,
+                       anorm,
+                       rcond,
+                       work,
+                       iwork,
+                       info)
+         rcond[0]
+      end
+   end
+end
+
+

data/lib/linalg/dmatrix/det.rb

@@ -0,0 +1,36 @@
+#
+# Copyright (c) 2004-2008 by James M. Lawrence
+#
+# See LICENSE
+#
+
+
+module Linalg
+   class DMatrix
+
+      #
+      # Returns the determinant of the matrix.  Raises
+      # +DimensionError+ if the matrix is not square.
+      #
+      def determinant
+         raise DimensionError unless square?
+         begin
+            a = self.clone
+            ipiv = a.lu!
+            res = 1.0
+            sign = 1
+            vsize.times { |i|
+               res *= a[i,i]
+               
+               # 1-based fortran
+               if ipiv[i] != i + 1
+                  sign *= -1 
+               end
+            }
+            res*sign
+         rescue SingularMatrix
+            0.0
+         end
+      end
+   end
+end

data/lib/linalg/dmatrix/eigen.rb

@@ -0,0 +1,153 @@
+#
+# Copyright (c) 2004-2008 by James M. Lawrence
+#
+# See LICENSE
+#
+
+
+
+module Linalg
+   class DMatrix
+
+      #
+      # call-seq:
+      #    eigensystem  => [eigvs, real, imag]
+      #    eigensystem { |eigvs, real, imag| ... } => block result
+      #
+      # Find the eigenvectors and eigenvalues of the matrix.
+      #
+      # The columns of +eigvs+ hold the eigenvectors; the column vectors
+      # +real+ and +imag+ hold the eigenvalues.
+      #
+      # Stepping through the eigenvalues in succession starting from the
+      # beginning, one will encounter either a real eigenvalue or a complex
+      # conjugate pair.  That is, either the imaginary part will be exactly
+      # equal to zero
+      #
+      #   imag[n] == 0.0
+      #
+      # or there will be a conjugate pair with the following exactly equal,
+      #
+      #   real[n] == real[n+1]
+      #   imag[n] == -imag[n+1]
+      #
+      # In the former case, the real eigenvector
+      #
+      #   eigvs.column(n)
+      #
+      # corresponds to the real eigenvalue
+      #
+      #   real[n]
+      #
+      # In the latter case, the complex eigenvector
+      #
+      #   eigvs.column(n) + i*eigvs.column(n+1)
+      #
+      # corresponds to the complex eigenvalue
+      #
+      #   real[n] + i*imag[n]
+      #
+      # and the conjugate eigenvector
+      #
+      #   eigvs.column(n) - i*eigvs.column(n+1)
+      #
+      # corresponds to the conjugate eigenvalue
+      #
+      #   real[n] - i*imag[n]
+      #
+      # for <tt>i = sqrt(-1)</tt>.
+      #
+      # The eigenvectors are each given unit length with largest component
+      # real.
+      #
+      # Raises +DimensionError+ if the given matrix is not square.  May
+      # raise +Diverged+.
+      #
+      def eigensystem(&b)
+         eigen_private(true, &b)
+      end
+
+      #
+      # call-seq:
+      #   eigenvalues  => [real, imag]
+      #   eigenvalues { |real, imag| ... } => block result 
+      #
+      # Returns the eigenvalues.  See DMatrix#eigensystem for the format in
+      # which eigenvalues are returned.
+      #
+      def eigenvalues(&b)
+         eigen_private(false, &b)
+      end
+      
+      private
+
+      def eigen_private(vecs)
+         raise DimensionError unless square?
+
+         jobvl = Char.new("N")
+         jobvr = Char.new(vecs ? "V" : "N")
+         n = XInteger.new(vsize)
+         a = self.clone
+         lda = XInteger.new(n.value)
+         wr = DMatrix.reserve(n.value, 1)
+         wi = DMatrix.reserve(n.value, 1)
+         vl = XData::NULL
+         ldvl = XInteger.new(1)
+         vr = DMatrix.reserve(n.value, n.value)
+         ldvr = XInteger.new(n.value)
+         work = DReal.new # query
+         lwork = XInteger.new(-1) # query
+         info = XInteger.new
+         
+         # query
+         Lapack.dgeev(jobvl,
+                      jobvr,
+                      n,
+                      a,
+                      lda,
+                      wr,
+                      wi,
+                      vl,
+                      ldvl,
+                      vr,
+                      ldvr,
+                      work,
+                      lwork,
+                      info)
+
+         raise Diverged unless info.value == 0
+         lwork = XInteger.new(work.value.to_i)
+         work = DData.new(lwork.value)
+
+         Lapack.dgeev(jobvl,
+                      jobvr,
+                      n,
+                      a,
+                      lda,
+                      wr,
+                      wi,
+                      vl,
+                      ldvl,
+                      vr,
+                      ldvr,
+                      work,
+                      lwork,
+                      info)
+         
+         raise Diverged unless info.value == 0
+         
+         if vecs
+            res = [vr, wr, wi]
+         else
+            res =  [wr, wi]
+         end
+
+         if block_given?
+            yield res
+         else
+            res
+         end
+      end
+   end
+end
+

data/lib/linalg/dmatrix/fit.rb

@@ -0,0 +1,281 @@
+#
+# Copyright (c) 2004-2008 by James M. Lawrence
+#
+# See LICENSE
+#
+
+
+module Linalg
+   class DMatrix
+      #
+      # Pseudo-inverse.
+      #
+      # For matrix +m+, find +x+ which minimizes
+      #   (m*x - DMatrix.identity(m.vsize)).norm
+      #
+      def pseudo_inverse(epsilon = nil)
+         DMatrix.fit(self, DMatrix.identity(vsize), epsilon)[0]
+      end
+
+      # call-seq:
+      #   fit(a, b, epsilon = nil)  => x
+      #   fit(a, b, epsilon = nil) { |x| ... }  => block value
+      #
+      # Least squares minimization using QR factorization.
+      #
+      # Find +x+ for which
+      #   (a*x - b).norm_2
+      # is a minimum.
+      #
+      # Assumes a matrix of full rank.
+      #
+      def self.fit(a, b)
+         raise DimensionError unless a.vsize == b.vsize
+         b_in = b
+
+         trans = Char.new("N")
+         m = XInteger.new(a.vsize)
+         n = XInteger.new(a.hsize)
+         nrhs = XInteger.new(b.hsize)
+         a = a.clone
+         lda = XInteger.new(a.vsize)
+         b = DMatrix.new(Math.max(m.value, n.value),
+                         nrhs.value).replace_minor(0, 0, b_in)
+         ldb = XInteger.new(b.vsize)
+         work = DReal.new # query
+         lwork = XInteger.new(-1) # query
+         info = XInteger.new
+         
+         # query
+         Lapack.dgels(trans,
+                      m,
+                      n,
+                      nrhs,
+                      a,
+                      lda,
+                      b,
+                      ldb,
+                      work,
+                      lwork,
+                      info)
+         
+         raise Diverged unless info.value == 0
+         lwork = XInteger.new(work.value.to_i)
+         work = DData.new(lwork.value)
+         
+         Lapack.dgels(trans,
+                      m,
+                      n,
+                      nrhs,
+                      a,
+                      lda,
+                      b,
+                      ldb,
+                      work,
+                      lwork,
+                      info)
+         
+         raise Diverged unless info.value == 0
+
+         x = b.minor(0, 0, n.value, nrhs.value)
+         if block_given?
+            yield x
+         else
+            x
+         end
+      end
+
+      private
+
+      #
+      # call-seq:
+      #   fit(a, b)  => [x, sv, rank]
+      #   fit(a, b) { |x, sv, rank| ... }  => block value
+      #
+      # Least squares minimization using singular value decomposition
+      # in conjunction with householder transformations.
+      # Rank deficiency is allowed.
+      #
+      # Find +x+ for which
+      #   (a*x - b).norm 
+      # is a minimum.  (+norm+ is the 2-norm.)
+      #
+      # Also returns the singular values +sv+ and the +rank+.
+      #
+      # For matrix +m+, a singular value less than or equal to
+      # <tt>m.norm*epsilon</tt> is considered a rank deficiency.  An
+      # +epsilon+ of +nil+ (default) specifies machine precision.
+      #
+      # Disabled.  Crash from a tester.
+      #
+      def self.fit_svdhh(a, b, epsilon = nil) # :yields: x, sv, rank
+         raise DimensionError unless a.vsize == b.vsize
+         b_in = b
+
+         m = XInteger.new(a.vsize)
+         n = XInteger.new(a.hsize)
+         nrhs = XInteger.new(b.hsize)
+         a = a.clone
+         lda = XInteger.new(a.vsize)
+         b = nil
+         ldb = XInteger.new(Math.max(m.value, n.value))
+         b = DMatrix.new(ldb.value, nrhs.value)
+         b.replace_minor(0, 0, b_in)
+         s = DMatrix.new(Math.min(m.value, n.value), 1)
+         rcond = DReal.new(epsilon ? epsilon : -1.0)
+         rank = XInteger.new
+         work = DReal.new # query
+         lwork = XInteger.new(-1) # query
+         # iwork defined below
+         info = XInteger.new
+
+         ###################################
+         # ilaenv 
+         ###################################
+         ary_name = "dgelsd".split("")
+
+         ispec = XInteger.new(9)
+         name = CharData.new(ary_name.size) { |i| ary_name[i] }
+         opts = Char.new("N")
+         nX = XInteger.new(0)
+         smlsiz = Lapack.ilaenv(ispec,
+                                name,
+                                opts,
+                                nX,
+                                nX,
+                                nX,
+                                nX)
+         raise "ilaenv: bad parameter #{-smlsiz}" if smlsiz < 0
+         
+         ###################################
+         # iwork
+         ###################################
+         minmn = Math.min(m.value, n.value)
+         nlvl = Math.max(0, (Math.log2(minmn.to_f/(smlsiz + 1))).to_i + 1)
+         iwork = IData.new(3*minmn*nlvl + 11*minmn)
+                                
+         ###################################
+         # dgesld
+         ###################################
+
+         # query
+         Lapack.dgelsd(m,
+                       n,
+                       nrhs,
+                       a,
+                       lda,
+                       b,
+                       ldb,
+                       s,
+                       rcond,
+                       rank,
+                       work,
+                       lwork,
+                       iwork,
+                       info)
+         
+         raise Diverged unless info.value == 0
+         lwork = XInteger.new(work.value.to_i)
+         work = DData.new(lwork.value)
+         
+         Lapack.dgelsd(m,
+                       n,
+                       nrhs,
+                       a,
+                       lda,
+                       b,
+                       ldb,
+                       s,
+                       rcond,
+                       rank,
+                       work,
+                       lwork,
+                       iwork,
+                       info)
+         
+         raise Diverged unless info.value == 0
+
+         res = [b.minor(0, 0, n.value, nrhs.value), s, rank.value]
+         if block_given?
+            yield res
+         else
+            res
+         end
+      end
+      
+      #
+      # call-seq:
+      #   fit_svd(a, b)  => [x, sv, rank]
+      #   fit_svd(a, b) { |x, sv, rank| ... }  => block value
+      #
+      # Least squares minimization with posible rank deficiency.
+      # Uses singular value decomposition.
+      #
+      # Disabled.  Crash for unknown reason.
+      #
+      def self.fit_svd2(a, b)
+         raise DimensionError unless a.vsize == b.vsize
+         b_in = b
+
+         m = XInteger.new a.vsize
+         n = XInteger.new a.hsize
+         nrhs = XInteger.new b.hsize
+         a = a.clone
+         lda = XInteger.new a.vsize
+         # b
+         ldb = XInteger.new Math.max(m.value, n.value)
+         b = DMatrix.new(ldb.value, nrhs.value)
+         b.replace_minor(0, 0, b_in)
+         s = DMatrix.new(Math.min(m.value, n.value), 1)
+         rcond = DReal.new(-1.0)  # use machine precision
+         rank = XInteger.new
+         work = DReal.new # query
+         lwork = XInteger.new(-1) # query
+         info = XInteger.new
+         
+         # query
+         Lapack.dgelss(m,
+                       n,
+                       nrhs,
+                       a,
+                       lda,
+                       b,
+                       ldb,
+                       s,
+                       rcond,
+                       rank,
+                       work,
+                       lwork,
+                       info)
+         
+         raise Diverged unless info.value == 0
+         lwork = XInteger.new(work.value.to_i)
+         work = DData.new(lwork.value)
+         
+         Lapack.dgelss(m,
+                       n,
+                       nrhs,
+                       a,
+                       lda,
+                       b,
+                       ldb,
+                       s,
+                       rcond,
+                       rank,
+                       work,
+                       lwork,
+                       info)
+         
+         raise Diverged unless info.value == 0
+
+         res = [b.minor(0, 0, a.hsize, b.hsize), s, rank.value]
+         if block_given?
+            yield res
+         else
+            res
+         end
+      end
+   end
+end
+
+