stick 1.3.2 → 1.3.3

data/lib/stick/matrix/exception.rb

@@ -0,0 +1,23 @@
+require 'e2mmap'
+
+module Stick
+
+  class Matrix
+
+    module Exceptions # :nodoc:
+      extend Exception2MessageMapper
+
+      def_e2message(TypeError, "wrong argument type %s (expected %s)")
+      def_e2message(ArgumentError, "Wrong # of arguments(%d for %d)")
+
+      def_exception("ErrDimensionMismatch", "\#{self.name} dimension mismatch")
+      def_exception("ErrNotRegular", "Not Regular Matrix")
+      def_exception("ErrOperationNotDefined", "This operation(%s) can\\'t defined")
+    end
+
+    #  extend Exception2MessageMapper
+    include Exceptions
+
+  end
+
+end

data/lib/stick/matrix/givens.rb

@@ -0,0 +1,59 @@
+module Stick
+
+  class Matrix
+
+    module Givens
+
+      # Returns the values "c and s" of a Given rotation
+      # MC, Golub, pg 216, Alghorithm 5.1.3
+
+      def Givens.givens(a, b)
+        if b == 0
+          c = 0; s = 0
+        else
+          if b.abs > a.abs
+            tau = Float(-a)/b; s = 1/Math.sqrt(1+tau**2); c = s * tau
+          else
+            tau = Float(-b)/a; c = 1/Math.sqrt(1+tau**2); s = c * tau
+          end
+        end
+        return c, s
+      end
+
+      # a QR factorization using Givens rotation
+      # Computes the upper triangular matrix R and the orthogonal matrix Q
+      # where Q^t A = R (MC, Golub, p227 algorithm 5.2.2)
+
+      def Givens.QR(mat)
+        r = mat.clone
+        m = r.row_size
+        n = r.column_size
+        q = Matrix.I(m)
+        n.times{|j|
+          m-1.downto(j+1){|i|
+            c, s = givens(r[i - 1, j], r[i, j])
+            qt = Matrix.I(m); qt[i-1..i, i-1..i] = Matrix[[c, s],[-s, c]]
+            q *= qt
+            r[i-1..i, j..n-1] = Matrix[[c, -s],[s, c]] * r[i-1..i, j..n-1]}}
+        return r, q
+      end
+
+    end
+
+    # Returns the upper triunghiular matrix R of a Givens QR factorization
+
+    def givensR
+      Givens.QR(self)[0]
+    end
+
+    # Returns the orthogonal matrix Q of Givens QR factorization.
+    # Q = G_1 * ... * G_t where G_j is the j'th Givens rotation
+    # and 't' is the total number of rotations
+
+    def givensQ
+      Givens.QR(self)[1]
+    end
+
+  end
+
+end

data/lib/stick/matrix/hessenberg.rb

@@ -0,0 +1,63 @@
+require 'stick/matrix/householder'
+
+module Stick
+
+  class Matrix
+
+    module Hessenberg
+
+      #  The matrix must be an upper R^(n x n) Hessenberg matrix
+
+      def Hessenberg.QR(mat)
+        r = mat.clone
+        n = r.row_size
+        q = Matrix.I(n)
+        for j in (0...n-1)
+          c, s = Givens.givens(r[j,j], r[j+1, j])
+          cs = Matrix[[c, s], [-s, c]]
+          q *= Matrix.diag(Matrix.I(j), cs, Matrix.I(n - j - 2))
+          r[j..j+1, j..n-1] = cs.t * r[j..j+1, j..n-1]
+        end
+        return q, r
+      end
+    end
+
+    # Returns the orthogonal matrix Q of Hessenberg QR factorization
+    # Q = G_1 *...* G_(n-1) where G_j is the Givens rotation G_j = G(j, j+1, omega_j)
+
+    def hessenbergQ
+      Hessenberg.QR(self)[0]
+    end
+
+    # Returns the upper triunghiular matrix R of a Hessenberg QR factorization
+
+    def hessenbergR
+      Hessenberg.QR(self)[1]
+    end
+
+    # Return an upper Hessenberg matrix obtained with Householder reduction to Hessenberg Form algorithm
+
+    def hessenberg_form_H
+      Householder.toHessenberg(self)[0]
+    end
+
+    # The real Schur decomposition.
+    # The eigenvalues are aproximated in diagonal elements of the real Schur decomposition matrix
+
+    def realSchur(eps = 1.0e-10, steps = 100)
+      h = self.hessenberg_form_H
+      h1 = Matrix[]
+      i = 0
+      loop do
+        h1 = h.hessenbergR * h.hessenbergQ
+        break if Matrix.diag_in_delta?(h1, h, eps) or steps <= 0
+        h = h1.clone
+        steps -= 1
+        i += 1
+      end
+      h1
+    end
+
+  end
+
+end

data/lib/stick/matrix/householder.rb

@@ -0,0 +1,106 @@
+module Stick
+
+  class Matrix
+
+    module Householder
+
+      # a QR factorization that uses Householder transformation
+      # Q^T * A = R
+      # MC, Golub & van Loan, pg 224, 5.2.1 Householder QR
+
+      def Householder.QR(mat)
+        h = []
+        a = mat.clone
+        m = a.row_size
+        n = a.column_size
+        n.times{|j|
+          v, beta = a[j..m - 1, j].house
+
+          h[j] = Matrix.diag(Matrix.I(j), Matrix.I(m-j)- beta * (v * v.t))
+
+          a[j..m-1, j..n-1] = (Matrix.I(m-j) - beta * (v * v.t)) * a[j..m-1, j..n-1]
+          a[(j+1)..m-1,j] = v[2..(m-j)] if j < m - 1 }
+        h
+      end
+
+      # From the essential part of Householder vector
+      # it returns the coresponding upper(U_j)/lower(V_j) matrix
+
+      def Householder.bidiagUV(essential, dim, beta)
+        v = Vector.concat(Vector[1], essential)
+        dimv = v.size
+        Matrix.diag(Matrix.I(dim - dimv), Matrix.I(dimv) - beta * (v * v.t) )
+      end
+
+      # Householder Bidiagonalization algorithm. MC, Golub, pg 252, Algorithm 5.4.2
+      # Returns the matrices U_B and V_B such that: U_B^T * A * V_B = B,
+      # where B is upper bidiagonal.
+
+      def Householder.bidiag(mat)
+        a = mat.clone
+        m = a.row_size
+        n = a.column_size
+        ub = Matrix.I(m)
+        vb = Matrix.I(n)
+        n.times{|j|
+          v, beta = a[j..m-1,j].house
+          a[j..m-1, j..n-1] = (Matrix.I(m-j) - beta * (v * v.t)) * a[j..m-1, j..n-1]
+          a[j+1..m-1, j] = v[1..(m-j-1)]
+          ub *= bidiagUV(a[j+1..m-1,j], m, beta) #Ub = U_1 * U_2 * ... * U_n
+          if j < n - 2
+            v, beta = (a[j, j+1..n-1]).house
+            a[j..m-1, j+1..n-1] = a[j..m-1, j+1..n-1] * (Matrix.I(n-j-1) - beta * (v * v.t))
+            a[j, j+2..n-1] = v[1..n-j-2]
+            vb  *= bidiagUV(a[j, j+2..n-1], n, beta) #Vb = V_1 * U_2 * ... * V_n-2
+          end  }
+        return ub, vb
+      end
+
+      # Householder Reduction to Hessenberg Form
+
+      def Householder.toHessenberg(mat)
+        h = mat.clone
+        n = h.row_size
+        u0 = Matrix.I(n)
+        for k in (0...n - 2)
+          v, beta = h[k+1..n-1, k].house #the householder matrice part
+          houseV = Matrix.I(n-k-1) - beta * (v * v.t)
+          u0 *= Matrix.diag(Matrix.I(k+1), houseV)
+          h[k+1..n-1, k..n-1] = houseV * h[k+1..n-1, k..n-1]
+          h[0..n-1, k+1..n-1] = h[0..n-1, k+1..n-1] * houseV
+        end
+        return h, u0
+      end
+
+    end #end of Householder module
+
+    # Returns the upper bidiagonal matrix obtained with Householder Bidiagonalization algorithm
+
+    def bidiagonal
+      ub, vb = Householder.bidiag(self)
+      ub.t * self * vb
+    end
+
+    # Returns the orthogonal matrix Q of Householder QR factorization
+    # where Q = H_1 * H_2 * H_3 * ... * H_n,
+
+    def houseQ
+      h = Householder.QR(self)
+      q = h[0]
+      (1...h.size).each{|i| q *= h[i]}
+      q
+    end
+
+    # Returns the matrix R of Householder QR factorization
+    # R = H_n * H_n-1 * ... * H_1 * A is an upper triangular matrix
+
+    def houseR
+      h = Householder.QR(self)
+      r = self.clone
+      h.size.times{|i| r = h[i] * r}
+      r
+    end
+
+  end
+
+end

data/lib/stick/matrix/jacobi.rb

@@ -0,0 +1,106 @@
+module Stick
+
+  class Matrix
+
+    module Jacobi
+
+      # Returns the nurm of the off-diagonal element
+
+      def Jacobi.off(a)
+        n = a.row_size
+        sum = 0
+        n.times{|i| n.times{|j| sum += a[i, j]**2 if j != i}}
+        Math.sqrt(sum)
+      end
+
+      # Returns the index pair (p, q) with 1<= p < q <= n and A[p, q] is the maximum in absolute value
+
+      def Jacobi.max(a)
+        n = a.row_size
+        max = 0
+        p = 0
+        q = 0
+        n.times{|i|
+          ((i+1)...n).each{|j|
+            val = a[i, j].abs
+            if val > max
+              max = val
+              p = i
+              q = j
+            end  }}
+        return p, q
+      end
+
+      # Compute the cosine-sine pair (c, s) for the element A[p, q]
+
+      def Jacobi.sym_schur2(a, p, q)
+        if a[p, q] != 0
+          tau = Float(a[q, q] - a[p, p])/(2 * a[p, q])
+          if tau >= 0
+            t = 1./(tau + Math.sqrt(1 + tau ** 2))
+          else
+            t = -1./(-tau + Math.sqrt(1 + tau ** 2))
+          end
+          c = 1./Math.sqrt(1 + t ** 2)
+          s = t * c
+        else
+          c = 1
+          s = 0
+        end
+        return c, s
+      end
+
+      # Returns the Jacobi rotation matrix
+
+      def Jacobi.J(p, q, c, s, n)
+        j = Matrix.I(n)
+        j[p,p] = c; j[p, q] = s
+        j[q,p] = -s; j[q, q] = c
+        j
+      end
+
+    end
+
+    # Classical Jacobi 8.4.3 Golub & van Loan
+
+    def cJacobi(tol = 1.0e-10)
+      a = self.clone
+      n = row_size
+      v = Matrix.I(n)
+      eps = tol * a.normF
+      while Jacobi.off(a) > eps
+        p, q = Jacobi.max(a)
+        c, s = Jacobi.sym_schur2(a, p, q)
+        #print "\np:#{p} q:#{q} c:#{c} s:#{s}\n"
+        j = Jacobi.J(p, q, c, s, n)
+        a = j.t * a * j
+        v = v * j
+      end
+      return a, v
+    end
+
+    # Returns the aproximation matrix computed with Classical Jacobi algorithm.
+    # The aproximate eigenvalues values are in the diagonal of the matrix A.
+
+    def cJacobiA(tol = 1.0e-10)
+      cJacobi(tol)[0]
+    end
+
+    # Returns a Vector with the eigenvalues aproximated values.
+    # The eigenvalues are computed with the Classic Jacobi Algorithm.
+
+    def eigenvaluesJacobi
+      a = cJacobiA
+      Vector[*(0...row_size).collect{|i| a[i, i]}]
+    end
+
+    # Returns the orthogonal matrix obtained with the Jacobi eigenvalue algorithm.
+    # The columns of V are the eigenvector.
+
+    def cJacobiV(tol = 1.0e-10)
+      cJacobi(tol)[1]
+    end
+
+  end
+
+end

data/lib/stick/matrix/lu.rb

@@ -0,0 +1,60 @@
+module Stick
+
+  class Matrix
+
+    module LU
+
+      #  Return the Gauss vector, MC, Golub, 3.2.1 Gauss Transformation, p94
+
+      def LU.gauss_vector(mat, k)
+        t = mat.column2matrix(k)
+        tk = t[k, 0]
+        (0..k).each{|i| t[i, 0] = 0}
+        return t if tk == 0
+        (k+1...mat.row_size).each{|i| t[i, 0] = t[i, 0].to_f / tk}
+        t
+      end
+
+      # Return the Gauss transformation matrix: M_k = I - tau * e_k^T
+
+      def LU.gauss(mat, k)
+        i = Matrix.I(mat.column_size)
+        tau = gauss_vector(mat, k)
+        e = i.row2matrix(k)
+        i - tau * e
+      end
+
+      # LU factorization: A = LU
+      # where L is lower triangular and U is upper triangular
+
+      def LU.factorization(mat)
+        u = mat.clone
+        n = u.column_size
+        i = Matrix.I(n)
+        l = i.clone
+        (n-1).times {|k|
+          mk = gauss(u, k)
+          u = mk * u  # M_{n-1} * ... * M_1 * A = U
+          l += i - mk  # L = M_1^{-1} * ... * M_{n-1}^{-1} = I + sum_{k=1}^{n-1} tau * e
+        }
+        return l, u
+      end
+    end
+
+    # Return the upper triangular matrix of LU factorization
+    # M_{n-1} * ... * M_1 * A = U
+
+    def U
+      LU.factorization(self)[1]
+    end
+
+    # Return the lower triangular matrix of LU factorization
+    # L = M_1^{-1} * ... * M_{n-1}^{-1} = I + sum_{k=1}^{n-1} tau * e
+
+    def L
+      LU.factorization(self)[0]
+    end
+
+  end
+
+end

data/lib/stick/quaternion.rb

@@ -3,7 +3,7 @@
 #   Quaternion
 #
 # Copyright:
-# 
+#
 #   Copyright (c) 2002 K. Kodama
 #
 # Authors:
@@ -23,9 +23,9 @@ require "complex"
 # NOTE This Quaternion class is still very experimental.
 #
 # Quaternions are attributed to Sir William Rowan Hamilton
-# who find it in 1843, and published a major analysis in 1844 called 
+# who find it in 1843, and published a major analysis in 1844 called
 # "On a Species of Imaginary Quantities Connected with a Theory of Quaternions"
-# in the Proceedings of the Royal Irish Academ. (2, pp 424-434). 
+# in the Proceedings of the Royal Irish Academ. (2, pp 424-434).
 #
 # Typical quaternion number q is of the form q = r + a i + b j + c k.
 # Bases i j k behaves as follows:
@@ -42,7 +42,7 @@ require "complex"
 #
 # A Quaternion q = r + a i + b j + k c have 1st level polar form such that
 #
-#    q = |q|(cos t1 + sin t1 u1) , where u1 is unit vector of u1 = a1 i + b1 j + c1 k. 
+#    q = |q|(cos t1 + sin t1 u1) , where u1 is unit vector of u1 = a1 i + b1 j + c1 k.
 #
 # u1 have 2nd level
 #
@@ -126,7 +126,7 @@ Quaternian::vector(v)
 Quaternion::rotation(v,t)
   # t-rotatin along the 3-D vector v
 q.rotate(r)
-  rotate by r = q r^(-1) 
+  rotate by r = q r^(-1)
 q.rotate_angle
   # = q.amplitude/2
 
@@ -189,7 +189,7 @@ q.sinh
 q.cosh
 q.tanh
 
-* Trigonometric functions 
+* Trigonometric functions
 q.sin
 q.cos
 q.tan
@@ -211,6 +211,7 @@ q.hash
 q.inspect
 =end
 
+module Stick
 
 def Quaternion(a=0, b=0,c=0, d=0)
   if a.kind_of?(Quaternion);
@@ -224,6 +225,8 @@ def Quaternion(a=0, b=0,c=0, d=0)
   end
 end
 
+module_function :Quaternion
+
 class Quaternion < Numeric
   attr :re
   attr :im
@@ -549,3 +552,4 @@ class Quaternion < Numeric
   end
 
 end # Quaternion
+end # Stick