extendmatrix 0.2.3 → 0.3.1

data/History.txt

@@ -1,3 +1,10 @@
+=== 0.3.1 / 2010-08-16
+* Bug fix: method mssq returns only the last row squares
+* Added method diagonal 
+
+=== 0.3.0 / 2010-08-16
+* Added new methods, inspired on SPSS matrix methods: e_mult, e_quo, mssq, eigen, eigenpairs, ln, sqrt, sscp
+
 === 0.2.3 / 2010-05-05
 * Added LICENSE.txt
 * Complete README.txt

data/lib/extendmatrix.rb

@@ -42,9 +42,9 @@ class Vector
   # Magnitude or length of the vector
   # Equal to sqrt(sum(x_i^2))
   def magnitude
-    Math::sqrt(to_a.inject(0) {|ac,v| ac+(v**2)}) 
+    Math::sqrt(to_a.inject(0) {|ac, v| ac+(v**2)})
   end
-  
+
   #
   # Sets a vector value/(range of values) with a new value/(values from a vector)
   # v = Vector[1, 2, 3]
@@ -65,7 +65,7 @@ class Vector
   class << self
     #
     # Returns a concatenated Vector
-    # 
+    #
     #   Vector.concat(Vector[1,2,3], Vector[4,5,6])
     #   => Vector[1, 2, 3, 4, 5, 6]
     #
@@ -105,7 +105,7 @@ class Vector
   end
   #
   # Returns the sum of values of the vector
-  # 
+  #
   def sum
     to_a.inject(&:+)
   end
@@ -222,7 +222,7 @@ end
 
 class Matrix
 
-  EXTENSION_VERSION="0.2.3"
+  EXTENSION_VERSION="0.3.1"
   include Enumerable
 
   attr_reader :rows, :wrap
@@ -330,17 +330,17 @@ class Matrix
 
 
   class << self
-     if !self.respond_to? :build
-	    #
-	    # Creates a matrix <tt>n</tt> x <tt>m</tt>
-	    # If you provide a block, it will be used to set the values.
-	    # If not, <tt>val</tt> will be used
-	    #
-	    
-	    def build(n,m,val=0)
-	      f = (block_given?)? lambda {|i,j| yield(i, j)} : lambda {|i,j| val}
-	      Matrix.rows((0...n).collect {|i| (0...m).collect {|j| f.call(i,j)}})
-	    end
+    if !self.respond_to? :build
+      #
+      # Creates a matrix <tt>n</tt> x <tt>m</tt>
+      # If you provide a block, it will be used to set the values.
+      # If not, <tt>val</tt> will be used
+      #
+
+      def build(n,m,val=0)
+        f = (block_given?)? lambda {|i,j| yield(i, j)} : lambda {|i,j| val}
+        Matrix.rows((0...n).collect {|i| (0...m).collect {|j| f.call(i,j)}})
+      end
     end
     #
     # Creates a matrix with the given matrices as diagonal blocks
@@ -392,7 +392,8 @@ class Matrix
   def quo(v)
     map {|e| e.quo(v)}
   end
-  alias :old_divition :/ 
+  
+  alias :old_divition :/
   #
   # quo seems always desirable
   #
@@ -412,136 +413,197 @@ class Matrix
 
   def wraplate(ijwrap = "")
     "class << self
-    def [](i, j)
+      def [](i, j)
       #{ijwrap}; @rows[i][j]
-    end
+      end
 
-    def []=(i, j, v)
+      def []=(i, j, v)
       #{ijwrap}; @rows[i][j] = v
-    end
-  end"
-end
+      end
+    end"
+  end
 
-#
-# Set wrap feature of a matrix
-#
-def wrap=(mode = :torus)
-  case mode
-  when :torus then eval(wraplate("i %= row_size; j %= column_size"))
-  when :h_cylinder then eval(wraplate("i %= row_size"))
-  when :v_cylinder then eval(wraplate("j %= column_size"))
-  when :nil then eval(wraplate)
-  end
-  @wrap = mode
-end
+  #
+  # Set wrap feature of a matrix
+  #
+  def wrap=(mode = :torus)
+    case mode
+    when :torus then eval(wraplate("i %= row_size; j %= column_size"))
+    when :h_cylinder then eval(wraplate("i %= row_size"))
+    when :v_cylinder then eval(wraplate("j %= column_size"))
+    when :nil then eval(wraplate)
+    end
+    @wrap = mode
+  end
 
-#
-# Returns the maximum length of column elements
-#
-def max_len_column(j)
-  column_collect(j) {|x| x.to_s.length}.max
-end
+  #
+  # Returns the maximum length of column elements
+  #
+  def max_len_column(j)
+    column_collect(j) {|x| x.to_s.length}.max
+  end
 
-#
-# Returns a list with the maximum lengths
-#
-def cols_len
-  (0...column_size).collect {|j| max_len_column(j)}
-end
+  #
+  # Returns a list with the maximum lengths
+  #
+  def cols_len
+    (0...column_size).collect {|j| max_len_column(j)}
+  end
 
-alias :to_s_old :to_s
+  alias :to_s_old :to_s
 
-#
-# Returns a string for nice printing matrix
-#
-def to_s(mode = :pretty, len_col = 3)
-  return super if empty?
-  if mode == :pretty
-    clen = cols_len
-    to_a.collect {|r|
-      i=0
-      r.map {|x|
-        l=clen[i]
-        i+=1
-        format("%#{l}s ", x.to_s)
-      } << "\n"
-    }.join("")
-  else
-    i = 0; s = ""; cs = column_size
-    each do |e|
-      i = (i + 1) % cs
-      s += format("%#{len_col}s ", e.to_s)
-      s += "\n" if i == 0
+  #
+  # Returns a string for nice printing matrix
+  #
+  def to_s(mode = :pretty, len_col = 3)
+    return "Matrix[]" if empty?
+    if mode == :pretty
+      clen = cols_len
+      to_a.collect {|r|
+        i=0
+        r.map {|x|
+          l=clen[i]
+          i+=1
+          format("%#{l}s ", x.to_s)
+        } << "\n"
+      }.join("")
+    else
+      i = 0; s = ""; cs = column_size
+      each do |e|
+        i = (i + 1) % cs
+        s += format("%#{len_col}s ", e.to_s)
+        s += "\n" if i == 0
+      end
+      s
     end
-    s
   end
-end
 
-#
-# Iterate the elements of a matrix
-#
-def each
-  @rows.each {|x| x.each {|e| yield(e)}}
-  nil
-end
-
-#
-# a hided module of Matrix
-module MMatrix
-  def self.default_block(block)
-    block ? lambda { |i| block.call(i) } : lambda {|i| i }
+  #
+  # Iterate the elements of a matrix
+  #
+  def each
+    @rows.each {|x| x.each {|e| yield(e)}}
+    nil
   end
-
   #
-  # Returns:
-  # 1) the index of row/column and
-  # 2) the values Vector for changing the row/column and
-  # 3) the range of changes
+  # :section: SPSS like methods
+  # 
+  
+  # Element wise operation
+  def elementwise_operation(op,other)
+    Matrix.build(row_size,column_size) do |row, column|
+      self[row,column].send(op,other[row,column])
+    end
+  end
+  # Element wise multiplication
+  def e_mult(other)
+    elementwise_operation(:*,other)
+  end
+  # Element wise multiplication
+  def e_quo(other)
+    elementwise_operation(:quo,other)
+  end
+  # Matrix sum of squares
+  def mssq
+    @rows.inject(0){|ac,row| ac+(row.inject(0) {|acr,i| acr+(i**2)})}
+  end
+  def eigenpairs
+    eigval, eigvec= eigenvaluesJacobi, cJacobiV
+    eigenpairs=eigval.size.times.map {|i|
+      [eigval[i], eigvec.column(i)]
+    }
+    eigenpairs=eigenpairs.sort{|a,b| a[0]<=>b[0]}.reverse
+  end
+  # Returns eigenvalues and eigenvectors of a matrix on a Hash
+  # like CALL EIGEN on SPSS.
+  # * _:eigenvectors_: contains the eigenvectors as columns of a new Matrix, ordered in descendent order
+  # * _:eigenvalues_:  contains an array with the eigenvalues, ordered in descendent order
+  def eigen
+    ep=eigenpairs
+    { :eigenvalues=>ep.map {|a| a[0]} ,
+      :eigenvectors=>Matrix.columns(ep.map{|a| a[1]})
+    }
+  end
+  # Returns a new matrix with the natural logarithm of initial values
+  def ln
+    map {|v| Math::log(v)}
+  end
+  # Returns a new matrix, with the square root of initial values
+  def sqrt
+    map {|v| Math::sqrt(v)}
+  end
+  # Sum of squares and cross-products. Equal to m.t * m
+  def sscp
+    transpose*self
+  end
+  # Diagonal of matrix.
+  # Returns an array with as many elements as the minimum of the number of rows
+  # and the number of columns in the argument
+  def diagonal
+    min = (row_size<column_size) ? row_size : column_size
+    min.times.map {|i| self[i,i]}
+  end
   #
-  def self.id_vect_range(args, l)
-    i = args[0] # the column(/the row) to be change
-    vect = args[1] # the values vector
+  # :section: Advanced methods
+  #
+  
+  #
+  # a hided module of Matrix
+  module MMatrix
+    def self.default_block(block)
+      block ? lambda { |i| block.call(i) } : lambda {|i| i }
+    end
 
-    case args.size
-    when 3 then range = args[2] # the range of the elements to be change
-    when 4 then range = args[2]..args[3] #the range by borders
-    else range = 0...l
+    #
+    # Returns:
+    # 1) the index of row/column and
+    # 2) the values Vector for changing the row/column and
+    # 3) the range of changes
+    #
+    def self.id_vect_range(args, l)
+      i = args[0] # the column(/the row) to be change
+      vect = args[1] # the values vector
+  
+      case args.size
+      when 3 then range = args[2] # the range of the elements to be change
+      when 4 then range = args[2]..args[3] #the range by borders
+      else range = 0...l
+      end
+      return i, vect, range
     end
-    return i, vect, range
+  
   end
 
-end
-
-#
-# Returns an array with the elements collected from the row "i".
-# When a block is given, the elements of that vector are iterated.
-#
-def row_collect(i, &block)
-  f = MMatrix.default_block(block)
-  @rows[i].collect {|e| f.call(e)}
-end
+  #
+  # Returns an array with the elements collected from the row "i".
+  # When a block is given, the elements of that vector are iterated.
+  #
+  def row_collect(i, &block)
+    f = MMatrix.default_block(block)
+    @rows[i].collect {|e| f.call(e)}
+  end
 
-#
-# Returns row vector number "i" like Matrix.row as a Vector.
-# When the block is given, the elements of row "i" are modified
-#
-def row!(i)
-  if block_given?
-    @rows[i].collect! {|e| yield e }
-  else
-    Vector.elements(@rows[i], false)
+  #
+  # Returns row vector number "i" like Matrix.row as a Vector.
+  # When the block is given, the elements of row "i" are modified
+  #
+  def row!(i)
+    if block_given?
+      @rows[i].collect! {|e| yield e }
+    else
+      Vector.elements(@rows[i], false)
+    end
   end
-end
-alias :row_collect! :row!
+  alias :row_collect! :row!
 
-#
-# Returns an array with the elements collected from the column "j".
-# When a block is given, the elements of that vector are iterated.
-#
-def column_collect(j, &block)
-  f = MMatrix.default_block(block)
-  (0...row_size).collect {|r| f.call(self[r, j])}
-end
+  #
+  # Returns an array with the elements collected from the column "j".
+  # When a block is given, the elements of that vector are iterated.
+  #
+  def column_collect(j, &block)
+    f = MMatrix.default_block(block)
+    (0...row_size).collect {|r| f.call(self[r, j])}
+  end
 
 #
 # Returns column vector number "j" as a Vector.
@@ -640,7 +702,7 @@ def row_sum
     row(i).sum
   }
 end
-# Returns  the  of columns
+# Returns  the marginal of columns
 def column_sum
   (0...column_size).collect {|i|
     column(i).sum
@@ -708,60 +770,59 @@ def L
   LU.factorization(self)[0]
 end
 
-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 self.QR(mat)
-    h = []
-    a = mat.clone
-    m = a.row_size
-    n = a.column_size
-    n.times do |j|
-      v, beta = a[j..m - 1, j].house
-      h[j] = Matrix.diag(Matrix.robust_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 
+  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 self.QR(mat)
+      h = []
+      a = mat.clone
+      m = a.row_size
+      n = a.column_size
+      n.times do |j|
+        v, beta = a[j..m - 1, j].house
+        h[j] = Matrix.diag(Matrix.robust_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
+      end
+      h
     end
-    h
-  end
-  #
-  # From the essential part of Householder vector
-  # it returns the coresponding upper(U_j)/lower(V_j) matrix
-  #
-  def self.bidiagUV(essential, dim, beta)
-    v = Vector.concat(Vector[1], essential)
-    dimv = v.size
-    
-    
-    Matrix.diag(Matrix.robust_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 self.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	}
+    #
+    # From the essential part of Householder vector
+    # it returns the coresponding upper(U_j)/lower(V_j) matrix
+    #
+    def self.bidiagUV(essential, dim, beta)
+      v = Vector.concat(Vector[1], essential)
+      dimv = v.size
+      Matrix.diag(Matrix.robust_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 self.bidiag(mat)
+      a = mat.clone
+      m = a.row_size
+      n = a.column_size
+      ub = Matrix.I(m)
+      vb = Matrix.I(n)
+      n.times do |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	
+      end
       return ub, vb
     end
 
@@ -781,8 +842,6 @@ module Householder
       end
       return h, u0
     end
-
-
   end #end of Householder module
 
   #
@@ -885,191 +944,194 @@ module Householder
           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
-
+        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 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
 
+  module Hessenberg
     #
-    # 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
+    #	the matrix must be an upper R^(n x n) Hessenberg matrix
     #
-    def givensQ
-      Givens.QR(self)[1]
+    def self.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.robust_I(j), cs, Matrix.robust_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
 
-    module Hessenberg
-      #
-      #	the matrix must be an upper R^(n x n) Hessenberg matrix
-      #
-      def self.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.robust_I(j), cs, Matrix.robust_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
+  #
+  # 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
+
 
+  module Jacobi
     #
-    # 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)
+    # Returns the nurm of the off-diagonal element
     #
-    def hessenbergQ
-      Hessenberg.QR(self)[0]
+    def self.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 upper triunghiular matrix R of a Hessenberg QR factorization
+    # Returns the index pair (p, q) with 1<= p < q <= n and A[p, q] is the maximum in absolute value
     #
-    def hessenbergR
-      Hessenberg.QR(self)[1]
+    def self.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
 
     #
-    # Return an upper Hessenberg matrix obtained with Householder reduction to Hessenberg Form algorithm
+    # Compute the cosine-sine pair (c, s) for the element A[p, q]
     #
-    def hessenberg_form_H
-      Householder.toHessenberg(self)[0]
+    def self.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
 
     #
-    # The real Schur decomposition.
-    # The eigenvalues are aproximated in diagonal elements of the real Schur decomposition matrix
+    # Returns the Jacobi rotation 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
+    def self.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
 
-    module Jacobi
-      #
-      # Returns the nurm of the off-diagonal element
-      #
-      def self.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 self.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 self.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 self.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 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 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
+  #
+  # 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
 
 

data/spec/extendmatrix_spec.rb

@@ -266,7 +266,46 @@ describe "Matrix class extension:" do
     m  = Matrix.build(5, 5){|i, j| i == j ? 1 + 0.001 * (i+1) : i + j}
     Matrix.diag_in_delta?(Matrix.I(5), m, 0.01).should == true
   end
-
+  
+  
+  it "e_mult method" do
+    m = Matrix.build(4, 3){|i, j| i * 3 + j +1}
+    n = Matrix.build(4, 3){|i, j| i * 2 + j +2}
+    m.e_mult(n).should==Matrix.build(4,3){|i,j| (i*3+j+1)*(i*2+j+2)}
+  end
+  it "e_mult method" do
+    m = Matrix.build(4, 3){|i, j| i * 3 + j +1}
+    n = Matrix.build(4, 3){|i, j| i * 2 + j +2}
+    m.e_quo(n).should==Matrix.build(4,3){|i,j| (i*3+j+1).quo(i*2+j+2)}
+  end
+  it "mssq method" do
+    m = Matrix[[1,2,3],[4,5,6],[7,8,9]]
+    m.mssq.should==(1..9).each.inject(0) {|ac,v| ac+v**2}
+  end
+  it "eigen" do
+    m=Matrix[[0.95,0.95,0.01,0.01],[0.95,0.95,0.01,0.01],[0.01, 0.01,0.95,0.95], [0.01, 0.01, 0.95, 0.95]]
+    eigenvalues=[1.92,1.88,0.0,0.0]
+    eigen=m.eigen
+    eigen[:eigenvalues].each_with_index do |v,i|
+      v.should be_close(eigenvalues[i],0.01)
+    end
+    eigenvectors=Matrix[[0.5, 0.5, 0.0, 0.707106781186547], [0.5, 0.5, 0.0, -0.707106781186547], [0.5, -0.5, 0.707106781186547, 0.0], [0.5, -0.5, -0.707106781186547, 0.0]]
+    Matrix.equal_in_delta?(eigen[:eigenvectors], eigenvectors).should be_true
+  end
+  it "sqrt" do
+    m=Matrix[[1,4,9],[16,25,36]]
+    m.sqrt.should==Matrix[[1,2,3],[4,5,6]]
+  end
+  it "sscp" do
+    m=Matrix[[1,4,9],[16,25,36]]
+    m.sscp.should== m.t*m
+  end
+  it "diagonal" do
+    m=Matrix.diag(1,4,5,6,7)
+    m.diagonal.should==[1,4,5,6,7]
+    m=Matrix[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]
+    m.diagonal.should==[1,5,9]  
+  end
   it "LU " do
     m = Matrix[[1, 4, 7],
       [2, 5, 8],
@@ -379,6 +418,6 @@ describe "Matrix class extension:" do
     [4, 5, 4, 1]]
     e = Matrix[[-0.26828, 0, 0, 0], [0, -5.97550, 0, 0], [0, 0, 1.01373, 0], [0, 0, 0, 9.23004]]
     Matrix.diag_in_delta?(e, a.cJacobiA, 1.0e-5).should == true
-  end
+  end  
 end
 

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
   - 3
-  version: 0.2.3
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Cosmin Bonchis
@@ -35,7 +35,7 @@ cert_chain:
   rpP0jjs0
   -----END CERTIFICATE-----
 
-date: 2010-05-07 00:00:00 -04:00
+date: 2010-08-16 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -62,8 +62,8 @@ dependencies:
         segments: 
         - 2
         - 6
-        - 0
-        version: 2.6.0
+        - 1
+        version: 2.6.1
   type: :development
   version_requirements: *id002
 description: |-