linalg 1.0.2

data/lib/linalg/dmatrix/inverse.rb

@@ -0,0 +1,78 @@
+#
+# Copyright (c) 2004-2008 by James M. Lawrence
+#
+# See LICENSE
+#
+
+
+module Linalg
+   class DMatrix
+
+      #
+      # call-seq: inverse
+      #
+      # Matrix inverse.  Raises +SingularMatrix+ if the matrix is
+      # singular.
+      #
+      def inverse
+         inverse_private(false)
+      end
+
+      #
+      # call-seq: inverse!
+      #
+      # In-place matrix inverse.  Raises +SingularMatrix+ if the matrix is
+      # singular.
+      #
+      #   a.object_id == a.inverse!.object_id
+      #
+      def inverse!
+         inverse_private(true)
+      end
+         
+      private
+      
+      def inverse_private(inplace)
+         raise DimensionError unless square?
+
+         m = XInteger.new(vsize)
+         n = m
+         a = inplace ? self : self.clone
+         lda = XInteger.new(n.value)
+         ipiv = IData.new(n.value)
+         info = XInteger.new
+         
+         Lapack.dgetrf(m,
+                       n,
+                       a,
+                       lda,
+                       ipiv,
+                       info)
+
+         raise SingularMatrix unless info.value == 0 
+         work = DReal.new # query
+         lwork = XInteger.new(-1) # query
+
+         Lapack.dgetri(n,
+                       a,
+                       lda,
+                       ipiv,
+                       work,
+                       lwork,
+                       info)
+         
+         raise SingularMatrix unless info.value == 0
+         lwork = XInteger.new(work.value.to_i)
+         work = DData.new(lwork.value)
+
+         Lapack.dgetri(n,
+                       a,
+                       lda,
+                       ipiv,
+                       work,
+                       lwork,
+                       info)
+         a
+      end
+   end
+end

data/lib/linalg/dmatrix/lu.rb

@@ -0,0 +1,120 @@
+#
+# Copyright (c) 2004-2008 by James M. Lawrence
+#
+# See LICENSE
+#
+
+
+module Linalg
+   class DMatrix
+      #
+      # call-seq:
+      #   lu  => [p, l, u]
+      #   lu { |p, l, u| ... }  => block result
+      #
+      # Generalized LU decomposition for rectangular matrices.
+      # The matrix is decomposed into
+      #
+      #   p * l * u
+      #
+      # where +p+ is a permutation matrix, +l+ lower-triangular
+      # (or lower-trapezoidal), and +u+ is upper-triangular (or
+      # upper-trapezoidal).
+      #
+      def lu # :yields: p, l, u
+         res = lu_private(false)
+         if block_given?
+            yield res
+         else
+            res
+         end
+      end
+
+      # 
+      # call-seq:
+      #   lu! => p
+      #
+      # In-place LU decomposition.  The matrix is overwritten with
+      # both L and U factors (the diagonal 1's of L are discarded).
+      # Returns the vector +p+ of pivots.
+      #
+      def lu!
+         lu_private(true)
+      end
+
+      def zero_lower # :nodoc:
+         if vsize > hsize
+            hsize
+         else
+            vsize - 1
+         end.times { |j|
+            replace_minor(j + 1, j, DMatrix.new(vsize - j - 1, 1))
+         }
+         self
+      end
+
+      def zero_upper # :nodoc:
+         # triangular portion
+         (1...Math.min(vsize, hsize)).each { |j|
+            replace_minor(0, j, DMatrix.new(j, 1))
+         }
+         
+         if hsize > vsize
+            # remaining
+            replace_minor(0, hsize, hsize - vsize, vsize)
+         end
+         
+         self
+      end
+
+      private
+
+      def lu_private(inplace)
+         minsize = Math.min(vsize, hsize)
+
+         m = XInteger.new vsize
+         n = XInteger.new hsize
+         a = inplace ? self : self.clone
+         lda = m
+         ipiv = IData.new minsize
+         info = XInteger.new
+
+         Lapack.dgetrf(m,
+                       n,
+                       a,
+                       lda,
+                       ipiv,
+                       info)
+
+         raise SingularMatrix unless info.value == 0
+         
+         if inplace
+            ipiv
+         else
+            p = DMatrix.identity(vsize)
+            if vsize > hsize
+               uvsize, uhsize = [minsize, minsize]
+               lvsize, lhsize = [vsize, hsize]
+            else
+               uvsize, uhsize = [vsize, hsize]
+               lvsize, lhsize = [minsize, minsize]
+            end
+
+            ipiv.each_with_index { |e, i|
+               # 1-based fortran
+               if i != e - 1
+                  p.exchange_columns(i, e - 1)
+               end
+            }
+
+            l = a.minor(0, 0, lvsize, lhsize).zero_upper
+            minsize.times { |i| l[i, i] = 1.0 }
+            u = a.minor(0, 0, uvsize, uhsize).zero_lower
+
+            [p, l, u]
+         end
+      end
+   end
+end
+
+

data/lib/linalg/dmatrix/main.rb

@@ -0,0 +1,244 @@
+#
+# Copyright (c) 2004-2008 by James M. Lawrence
+#
+# See LICENSE
+#
+
+module Linalg
+   
+   class DMatrix
+      include Iterators
+
+      include XData # :nodoc:
+      include Linalg::Exception # :nodoc:
+
+
+      ##################################################
+      #
+      # singleton methods
+      #
+      ##################################################
+
+      #
+      # Create a matrix by joining together a list of column vectors
+      #
+      #   m == DMatrix.join_columns(m.columns.map { |x| x })
+      #
+      def self.join_columns(cols)
+         col_vsize = cols[0].vsize
+         res = DMatrix.reserve(col_vsize, cols.size)
+         cols.each_with_index { |col, j|
+            unless col.vsize == col_vsize
+               raise DimensionError 
+            end
+            res.replace_column(j, col)
+         }
+         res
+      end
+
+      #
+      # Create a matrix by joining together a list of row vectors
+      #
+      #   m == DMatrix.join_rows(m.rows.map { |x| x })
+      #
+      def self.join_rows(rows)
+         row_hsize = rows[0].hsize
+         res = DMatrix.reserve(rows.size, row_hsize)
+         rows.each_with_index { |row, i|
+            unless row.hsize == row_hsize
+               raise DimensionError 
+            end
+            res.replace_row(i, row)
+         }
+         res
+      end
+
+      #
+      # calls DMatrix.rows with a splat (*)
+      #
+      #   DMatrix[[1,2,3],[4,5,6]] 
+      # is equivalent to
+      #   DMatrix.rows [[1,2,3],[4,5,6]]
+      #
+      def self.[](*array)
+         self.rows(array)
+      end
+
+      #
+      # Create a matrix using the elements of +array+ as columns.
+      #
+      #   DMatrix.columns(array)
+      # is equivalent to
+      #   DMatrix.new(array[0].size, array.size) { |i,j| array[j][i] }
+      #
+      # +DimensionError+ is raised if +array+ is not rectangular.
+      # 
+      def self.columns(array)
+         self.rows(array).transpose!
+      end
+
+      class << self
+         attr_accessor :default_epsilon
+      end
+      
+      #
+      # rdoc can you see me?
+      #
+      self.default_epsilon = 1e-8
+
+      ##################################################
+      #
+      # instance methods
+      #
+      ##################################################
+
+      #
+      # Returns the singleton class of the object.  Convenient for
+      # setting the +default_epsilon+ on a per-object basis.
+      #   b = DMatrix.rand(4, 4)
+      #   a = b.map { |e| e + 0.0001 }
+      #   a.class.default_epsilon  # => 1e-8
+      #   a =~ b  # => false
+      #   a.singleton_class.default_epsilon = 0.001
+      #   a =~ b  # => true
+      #
+      def singleton_class
+         class << self
+            self
+         end
+      end
+
+      #
+      # True if element-wise identical values.
+      #
+      def ==(other)
+         self.within(0.0, other)
+      end
+
+      #
+      # Sum of diagonal elements.
+      #
+      def trace
+         diags.inject(0.0) { |acc, e| acc + e }
+      end
+
+      #
+      # Same as to_s but prepended with a newline for nice irb output
+      #
+      def inspect
+         "\n" << self.to_s
+      end
+
+      #
+      # Dump to an +eval+-able string
+      #
+      def inspect2
+         res = "#{self.class}["
+         vsize.times { |i|
+            res << "["
+            hsize.times { |j|
+               res << self[i,j].to_s << ","
+            }
+            res.chop!
+            res << "],"
+         }
+         res.chop!
+         res << "]"
+      end
+      
+      #
+      # Dump to a readable string
+      #
+      def to_s(format = "% 10.6f")
+         res = ""
+         vsize.times { |i|
+            hsize.times { |j|
+               res << sprintf(format, self[i,j])
+            }
+            res << "\n"
+         }
+         res
+      end
+
+      #
+      # Returns <tt>m[0,0]</tt> when +m+ is a 1x1 matrix, otherwise a
+      # +TypeError+ is raised.
+      #
+      def to_f
+         if vsize == 1 and hsize == 1
+            self[0,0]
+         else
+            raise TypeError, "to_f called on nonscalar matrix"
+         end
+      end
+
+      #
+      # Implemented as
+      #
+      #   m.within(epsilon, other)
+      #
+      # where
+      #   epsilon =
+      #      self.singleton_class.default_epsilon ||
+      #      self.class.default_epsilon
+      #
+      def =~(other)
+         epsilon =
+            self.singleton_class.default_epsilon ||
+            self.class.default_epsilon
+
+         self.within(epsilon, other)
+      end
+
+      #
+      # Returns
+      #   self.vsize == self.hsize
+      #
+      def square?
+         self.vsize == self.hsize
+      end
+
+      #
+      # Tests whether the matrix is symmetric within +epsilon+
+      #
+      def symmetric?(epsilon = (self.singleton_class.default_epsilon || self.class.default_epsilon))
+         symmetric_private(epsilon)
+      end
+
+      #
+      # Exchange the <tt>p</tt>-th row with the <tt>q</tt>-th row
+      # 
+      def exchange_rows(p, q)
+         tmp = self.row(p)
+         replace_row(p, self.row(q))
+         replace_row(q, tmp)
+      end
+      
+      #
+      # Exchange the <tt>p</tt>-th column with the <tt>q</tt>-th column
+      # 
+      def exchange_columns(p, q)
+         tmp = self.column(p)
+         replace_column(p, self.column(q))
+         replace_column(q, tmp)
+      end
+      
+      private
+
+      #
+      # Create a column vector from the array
+      #
+      def self.column_vector(array)
+         self.columns([array])
+      end
+
+      #
+      # Create a row vector from the array
+      #
+      def self.row_vector(array)
+         self.rows([array])
+      end
+
+   end
+end
+

data/lib/linalg/dmatrix/norms.rb

@@ -0,0 +1,88 @@
+#
+# Copyright (c) 2004-2008 by James M. Lawrence
+#
+# See LICENSE
+#
+
+module Linalg
+   class DMatrix
+      #
+      # The 2-norm.  The largest singular value.
+      #
+      def norm_2
+         singular_values[0]
+      end
+
+      #
+      # call-seq: norm_1
+      #
+      # The 1-norm.  Maximum column absolute sum.
+      # For matrix +m+, equivalent to
+      #
+      #   m.columns.map { |col|
+      #      col.elems.inject(0.0) { |acc, e| acc + e.abs }
+      #   }.sort[-1]
+      #
+      def norm_1
+         private_norm(Char.new("1"), NULL)
+      end
+      
+      #
+      # call-seq: norm_inf
+      #
+      # The infinity-norm.  Maximum row absolute sum.
+      # For matrix +m+, equivalent to
+      #
+      #   m.rows.map { |row|
+      #      row.elems.inject(0.0) { |acc, e| acc + e.abs }
+      #   }.sort[-1]
+      #
+      def norm_inf
+         private_norm(Char.new("I"), DData.new(vsize))
+      end
+
+      #
+      # call-seq: norm_f
+      #
+      #
+      # Frobenius norm.  Square root of the sum of the squares of the
+      # elements.
+      #
+      # For matrix +m+, equivalent to
+      #
+      #   Math.sqrt(m.elems.inject(0.0) { |acc, e| acc + e*e })
+      #
+      #
+      def norm_f
+         private_norm(Char.new("F"), NULL)
+      end
+
+      #
+      # call-seq: maxabs
+      #
+      # The maximum absolute value of the individual matrix elements.
+      # For matrix +m+, equivalent to
+      #
+      #   m.elems.map { |e| e.abs }.to_a.flatten.sort[-1]
+      #
+      # Note +maxabs+ is not a matrix norm.
+      #
+      #
+      def maxabs
+         private_norm(Char.new("M"), NULL)
+      end
+
+      private
+
+      def private_norm(kind, work)
+         m = XInteger.new(vsize)
+         n = XInteger.new(hsize)
+         Lapack.dlange(kind,
+                       m,
+                       n,
+                       self,
+                       m,
+                       work)
+      end
+   end
+end