linalg 1.0.2

data/lib/linalg/dmatrix/nullspace.rb

@@ -0,0 +1,114 @@
+#
+# Copyright (c) 2004-2008 by James M. Lawrence
+#
+# See LICENSE
+#
+
+
+module Linalg
+   class DMatrix
+      #
+      # Returns a matrix whose columns form an orthogonal basis for the
+      # nullspace.  (This is simply taken from <tt>vt.t</tt> in DMatrix#svd.)
+      # Returns +nil+ if the matrix is of full rank.
+      #
+      # For matrix +m+, a singular value less than or equal
+      # to <tt>m.norm*epsilon</tt> is considered a rank
+      # deficiency.
+      #
+      def nullspace(epsilon = (self.singleton_class.default_epsilon ||self.class.default_epsilon))
+         u, s, vt = self.svd
+         v = vt.transpose!
+         null_indexes = sv_null_indexes(s.diags, s[0,0]*epsilon)
+
+         if null_indexes.empty?
+            nil
+         else
+            ns = DMatrix.reserve(v.vsize, null_indexes.size)
+            null_indexes.each_with_index { |e, j|
+               ns.replace_column(j, v.column(e))
+            }
+            ns
+         end
+      end
+
+      #
+      # Returns a matrix whose columns form an orthonormal basis
+      # for the span of the matrix.
+      #
+      # This is just the complement of the nullspace.
+      # See DMatrix#nullspace.
+      #
+      def rankspace(epsilon = (self.singleton_class.default_epsilon ||self.class.default_epsilon))
+         u, s, vt = self.svd
+         v = vt.transpose!
+         null_indexes = sv_null_indexes(s.diags, s[0,0]*epsilon)
+
+         if null_indexes.empty?
+            v
+         else
+            orth_indexes = (0...v.hsize).to_a - null_indexes
+            orth = DMatrix.reserve(v.vsize, orth_indexes.size)
+            orth_indexes.each_with_index { |e, j|
+               orth.replace_column(j, v.column(e))
+            }
+            orth
+         end
+      end
+
+      #
+      # Returns the column rank of the matrix.
+      #   hsize == rank + nullity
+      #
+      # see DMatrix#nullspace
+      #
+      def rank(epsilon = (self.singleton_class.default_epsilon ||self.class.default_epsilon))
+         sv = self.sv
+         indexes = sv_null_indexes(sv, sv[0]*epsilon)
+         indexes ? (hsize - indexes.size) : 0
+      end
+
+      #
+      # Returns the nullity of the matrix (the dimension of the nullspace).
+      #   hsize == rank + nullity
+      #
+      # see DMatrix#nullspace
+      #
+      def nullity(epsilon = self.class.default_epsilon)
+         sv = self.sv
+         indexes = sv_null_indexes(sv, sv[0]*epsilon)
+         indexes ? indexes.size : 0
+      end
+      
+      #
+      # True if the rank less than number of columns.
+      #
+      # see DMatrix#nullspace
+      #
+      def singular?(epsilon = (self.singleton_class.default_epsilon ||self.class.default_epsilon))
+         not regular?(epsilon)
+      end
+
+      #
+      # True if the rank is equal to the number of columns.
+      #
+      # see DMatrix#nullspace
+      #
+      def regular?(epsilon = (self.singleton_class.default_epsilon ||self.class.default_epsilon))
+         square? and rank(epsilon) == hsize
+      end
+
+      private
+
+      def sv_null_indexes(sv, epsilon)
+         nulls = []
+         sv.each_with_index { |e, i|
+            nulls << i if e.abs <= epsilon 
+         }
+         nulls += (self.vsize...self.hsize).to_a
+         nulls
+      end
+   end
+end
+
+

data/lib/linalg/dmatrix/qr.rb

@@ -0,0 +1,129 @@
+#
+# Copyright (c) 2004-2008 by James M. Lawrence
+#
+# See LICENSE
+#
+
+module Linalg
+   class DMatrix
+      #
+      # call-seq:
+      #   qr  => [q, r]
+      #   qr { |q, r| ... }  => block result
+      #
+      # QR factorization.  Decompose the matrix into
+      #   q * r
+      # where +q+ is orthogonal and +r+ is upper-triangular.
+      #
+      def qr # :yields: q, r
+         res = qr_private(false)
+         if block_given?
+            yield res
+         else
+            res
+         end
+      end
+
+      #
+      # In-place QR factorization.  The contents of the matrix are
+      # left in the state returned by dgeqrf().
+      #
+      def qr!
+         qr_private(true)
+      end
+
+      private
+
+      def qr_private(inplace)
+         mindim = Math.min(vsize, hsize)
+
+         m = XInteger.new(vsize)
+         n = XInteger.new(hsize)
+         a = inplace ? self : self.clone
+         lda = m
+         tau = DData.new(mindim)
+         work = DReal.new  # query
+         lwork = XInteger.new(-1)  # query
+         info = XInteger.new
+
+         # query
+         Lapack.dgeqrf(m,
+                       n,
+                       a,
+                       lda,
+                       tau,
+                       work,
+                       lwork,
+                       info)
+
+         raise Diverged unless info.value == 0
+         lwork[0] = work[0].to_i
+         work = DData.new(lwork[0])
+         
+         Lapack.dgeqrf(m,
+                       n,
+                       a,
+                       lda,
+                       tau,
+                       work,
+                       lwork,
+                       info)
+         
+         raise Diverged unless info.value == 0
+
+         return self if inplace
+         
+         r = a.clone.zero_lower
+         
+         iden = DMatrix.identity(vsize)
+         q = iden.clone
+
+         v = DMatrix.reserve(vsize, 1)
+
+         transa = Char.new("N")
+         transb = Char.new("T")
+         alpha = DReal.new
+         neg_one = DReal.new(-1.0)
+         one = XInteger.new(1)
+         d_one = DReal.new(1.0)
+         
+         mindim.times { |p|
+            v.fill(0.0)
+            v[p] = 1.0
+            if p < vsize - 1
+               v.replace_minor(p + 1, 0, a.minor(p + 1,
+                                                 p,
+                                                 vsize - p - 1,
+                                                 1))
+            end
+            
+            # using dgemm instead
+            #h = iden - tau[p]*v*v.t
+
+            # this is not worth it ...
+            alpha[0] = -tau[p]
+            h = iden.clone
+            Lapack.dgemm(transa,
+                         transb,
+                         m, # m
+                         m, # n
+                         one, # k
+                         alpha,
+                         v, # a
+                         m, # lda
+                         v, # b
+                         m, # ldb
+                         d_one, # beta
+                         h, # c
+                         m) # ldc
+            q.postmul!(h)
+         }
+         
+         [q, r]
+      end
+   end
+end
+
+
+
+

data/lib/linalg/dmatrix/schur.rb

@@ -0,0 +1,88 @@
+#
+# Copyright (c) 2004-2008 by James M. Lawrence
+#
+# See LICENSE
+#
+
+
+module Linalg
+   class DMatrix
+      #
+      # call-seq:
+      #   schur  => [z, t, real, imag]
+      #   schur { |z, t, real, imag| ... }  => block result
+      #
+      # Decompose into
+      #   z * t * z.t
+      # where +z+ is orthogonal and +t+ is quasi upper-diagonal.
+      # +real+ and +imag+ contain the respective eigenvalues in the format
+      # described in DMatrix#eigensystem.
+      # 
+      def schur # :yields: z, t, real, imag
+         raise DimensionError unless square?
+         jobvs = Char.new("V")
+         sort = Char.new("N")
+         select = XData::NULL
+         n = XInteger.new(vsize)
+         a = self.clone
+         lda = n
+         sdim = XInteger.new
+         wr = DMatrix.reserve(n.value, 1)
+         wi = DMatrix.reserve(n.value, 1)
+         vs = DMatrix.reserve(n.value, n.value)
+         ldvs = n
+         work = DReal.new  # query
+         lwork = XInteger.new(-1) # query
+         bwork = XData::NULL
+         info = XInteger.new
+         
+         # query
+         Lapack.dgees(jobvs,
+                      sort,
+                      select,
+                      n,
+                      a,
+                      lda,
+                      sdim,
+                      wr,
+                      wi,
+                      vs,
+                      ldvs,
+                      work,
+                      lwork,
+                      bwork,
+                      info)
+         
+         raise Diverged unless info.value == 0
+         lwork = XInteger.new(work.value.to_i)
+         work = DData.new(lwork.value)
+         
+         Lapack.dgees(jobvs,
+                      sort,
+                      select,
+                      n,
+                      a,
+                      lda,
+                      sdim,
+                      wr,
+                      wi,
+                      vs,
+                      ldvs,
+                      work,
+                      lwork,
+                      bwork,
+                      info)
+         
+         raise Diverged unless info.value == 0
+
+         res = [vs, a, wr, wi]
+         if block_given?
+            yield res
+         else
+            res
+         end
+      end
+   end
+end
+
+

data/lib/linalg/dmatrix/solve.rb

@@ -0,0 +1,78 @@
+#
+# Copyright (c) 2004-2008 by James M. Lawrence
+#
+# See LICENSE
+#
+
+
+module Linalg
+   class DMatrix
+      
+      #
+      # call-seq: solve(a, b)
+      # 
+      # Solve the linear equation
+      #
+      #   a * x == b
+      #
+      # Returns the solution +x+, or raises +SingularMatrix+ if +a+ was
+      # singular.
+      #
+      #
+      def self.solve(a, b)
+         solve_private(a, b, false)
+      end
+
+      #
+      # call-seq: solve!(a, b)
+      # 
+      # Solve the linear equation
+      #
+      #   a * x == b
+      #
+      # +a+ and +b+ are *both* *overwritten*.
+      #
+      # If a unique solution is found, +a+ contains both L and U factors
+      # while +b+ holds the solution +x+ above.
+      #
+      # Returns the solution +x+, or raises +SingularMatrix+ if +a+ was
+      # singular.
+      #
+      #   x = DMatrix.solve!(a, b)
+      #   x.object_id == b.object_id
+      #
+      #
+      def self.solve!(a, b)
+         solve_private(a, b, true)
+      end
+
+      private
+
+      def self.solve_private(a, b, inplace)
+         unless a.square? and a.vsize == b.vsize
+            raise DimensionError
+         end
+    
+         n = XInteger.new(a.vsize)
+         nrhs = XInteger.new(b.hsize)
+         a = inplace ? a : a.clone
+         lda = XInteger.new(a.vsize)
+         ipiv = IData.new(n.value)
+         b = inplace ? b : b.clone
+         ldb = XInteger.new(b.vsize)
+         info = XInteger.new
+
+         Lapack.dgesv(n,
+                      nrhs,
+                      a,
+                      lda,
+                      ipiv,
+                      b,
+                      ldb,
+                      info)
+         
+         raise SingularMatrix unless info.value == 0
+         b
+      end
+   end
+end

data/lib/linalg/dmatrix/svd.rb

@@ -0,0 +1,125 @@
+#
+# Copyright (c) 2004-2008 by James M. Lawrence
+#
+# See LICENSE
+#
+
+
+module Linalg
+   class DMatrix
+      #
+      # call-seq:
+      #   singular_value_decomposition  => [u, s, vt]
+      #   singular_value_decomposition { |u, s, vt| ... }  => block result
+      #
+      # Decompose the +m+ x +n+ matrix into
+      #
+      #   u * s * vt
+      #
+      # where +u+ and +vt+ are orthogonal matrices and +s+ is an +m+ x +n+
+      # matrix whose non-diagonal elements are all zero.  The diagonal
+      # elements of +s+ are called the <em>singular values</em> of the
+      # matrix.  If called with
+      #   m.singular_value_decomposition(:diagonalize => false)
+      # then +s+ is a vector of singular values rather than a diagonal
+      # matrix.
+      #
+      # May raise +Diverged+.
+      #
+      def singular_value_decomposition(opts = nil, &b)
+         if opts
+            svd_private(true, opts[:diagonalize], &b)
+         else
+            svd_private(true, true, &b)
+         end
+      end
+
+      #
+      # call-seq:
+      #   singular_values  => s
+      #   singular_values { |s| .. }  => block result
+      #
+      # Returns a vector containing the singular values of the matrix.  See
+      # DMatrix#singular_value_decomposition.
+      #
+      def singular_values(&b)
+         svd_private(false, false, &b)
+      end
+
+      private
+
+      def svd_private(decomp, diagonalize)
+         jobu = Char.new(decomp ? "A" : "N")
+         jobvt = Char.new(decomp ? "A" : "N")
+         m = XInteger.new(vsize)
+         n = XInteger.new(hsize)
+         a = self.clone
+         lda = XInteger.new(a.vsize)
+         s = DMatrix.new(Math.min(vsize, hsize), 1)
+         u =  decomp ? DMatrix.reserve(vsize, vsize) : DMatrix.reserve(1, 1)
+         ldu = XInteger.new(u.vsize)
+         vt = decomp ? DMatrix.reserve(hsize, hsize) : DMatrix.reserve(1, 1)
+         ldvt = XInteger.new(vt.vsize)
+         work = DReal.new
+         lwork = XInteger.new(-1) # query
+         info = XInteger.new
+
+         # query
+         Lapack.dgesvd(jobu,
+                       jobvt,
+                       m,
+                       n,
+                       a,
+                       lda,
+                       s,
+                       u,
+                       ldu,
+                       vt,
+                       ldvt,
+                       work,
+                       lwork,
+                       info)
+         
+         raise Diverged unless info.value == 0
+         lwork = XInteger.new(work.value.to_i)
+         work = DData.new(lwork.value)
+         
+         Lapack.dgesvd(jobu,
+                       jobvt,
+                       m,
+                       n,
+                       a,
+                       lda,
+                       s,
+                       u,
+                       ldu,
+                       vt,
+                       ldvt,
+                       work,
+                       lwork,
+                       info)
+         
+         if decomp
+            if diagonalize
+               sm = DMatrix.new(vsize, hsize)
+               Math.min(vsize, hsize).times { |i|
+                  sm[i, i] = s[i]
+               }
+               res = [u, sm, vt]
+            else
+               res = [u, s, vt]
+            end
+         else
+            res = s
+         end
+
+         if block_given?
+            yield res
+         else
+            res
+         end
+      end
+   end
+end
+
+