gsl 1.12.109 → 1.14.5

data/examples/linalg/LU.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+include Linalg
+
+m = Matrix::alloc([0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58],
+		    [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85])
+m.print
+
+lu, perm = m.LU_decomp
+m.print
+lu.print
+
+b = Vector[1, 2, 3, 4]
+x = LU.solve(lu, perm, b)
+x = LU.solve(lu, perm, b)
+p x
+p m
+
+p m.LU_solve(b)
+p m.LU_solve(perm, b)
+p m.LU_solve(perm, b, x)
+p lu.LU_solve(perm, b, x)
+
+p x
+LU.refine(m, lu, perm, b, x)
+p x
+
+#p b
+#m.LU_svx(b)
+#p b
+#LU.svx(lu, perm, b)
+#p b
+#p m.LU_solve(perm, b)
+#p m.LU_solve(perm, b, x)
+#p lu.LU_solve(perm, b, x)
+
+#exit
+
+LU.svx(lu, perm, b)
+p b
+
+p m*x.col
+
+b = [1, 2, 3, 4].to_gv
+p LU.solve(m, b)
+
+puts("")
+
+m2 = Matrix.alloc([1, 2, 3, 6, 5, 4, 7, 8, 1], 3, 3)
+m2.print
+lu2, p2, sign = m2.LU_decomp
+
+m3 = Matrix.alloc([1, 2, 3, 4, 5, 6, 7, 8, 0], 3, 3)
+m3.print
+lu, perm = m3.LU_decomp
+LU.invert(lu, perm).print
+p m3.class
+p lu.class
+m4 = m3.invert
+LU.invert(m3).print
+p m4.invert
+p m3.invert.invert.invert
+
+p m2.det
+p lu2.det(p2, sign)
+p m2.det(p2)
+
+p LU.det(m2)
+
+p LU.lndet(m2)
+p LU.lndet(lu2)
+p m2.lndet
+p lu2.lndet
+
+p LU.sgndet(m2)
+p LU.sgndet(lu2, sign)
+p m2.sgndet
+p lu2.sgndet(sign)
+
+p m
+p m/b.col
+
+__END__

data/examples/linalg/LU2.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+include Linalg
+
+m = Matrix::alloc([0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58],
+		    [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85])
+m.print
+
+lu, perm = m.LU_decomp
+
+b = [1, 2, 3, 4]
+x = Vector.alloc(4)
+
+p m.class
+
+p LU.solve(lu, perm, b)
+LU.solve(lu, perm, b, x)
+p x
+p LU.solve(m, b)
+LU.solve(m, b, x)
+p x
+
+LU.solve(m, perm, b, x)
+p x
+
+bv = b.to_gv
+LU.svx(m, perm, bv)
+p bv
+
+m.print

data/examples/linalg/LU_narray.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+include Linalg
+
+m = NArray[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58],
+		    [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]]
+b = NArray[1.0, 2, 3, 4]
+
+lu, perm, signum = LU.decomp(m)
+p m
+p lu
+
+x = LU.solve(lu, perm, b)
+p x
+p b
+
+LU.svx(lu, perm, b)
+p b
+
+m2 = Matrix.alloc([1, 2, 3, 6, 5, 4, 7, 8, 1], 3, 3).to_nmatrix
+lu, perm, signum = LU.decomp(m2)
+p LU.det(lu, signum)
+

data/examples/linalg/PTLQ.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+
+m = Matrix::alloc([0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58],
+		    [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85])
+m.transpose!
+lq, tau = m.PTLQ_decomp
+p lq.class
+p tau.class
+
+b = Vector[1, 2, 3, 4]
+
+lq, tau, p = m.PTLQ_decomp
+
+p Linalg::PTLQ.solve_T(lq, tau, p, b)
+p Linalg::PTLQ.solve_T(m, b)
+p m.PTLQ_solve_T(b)
+p lq.PTLQ_solve_T(tau, p, b)
+p m.PTLQ_solve_T(b)
+
+bb = b.clone
+p Linalg::PTLQ.solve_T(lq, tau, p, bb)
+bb = b.clone
+p Linalg::PTLQ.solve_T(m, bb)
+bb = b.clone
+p m.PTLQ_solve_T(b)
+bb = b.clone
+p lq.PTLQ_solve_T(tau, p, bb)
+bb = b.clone
+p m.PTLQ_solve_T(bb)
+bb = b.clone
+p lq.class
+p lq.solve_T(tau, p, bb)
+
+q, l, tau, p = m.PTLQ_decomp2
+p q.class
+p l.class
+
+p Linalg::PTLQ.LQsolve_T(q, l, p, b)
+
+bb = b.clone
+lq.svx_T(tau, p, bb)
+p bb
+bb = b.clone
+m.PTLQ_svx_T(bb)
+p bb

data/examples/linalg/QR.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+
+m = Matrix[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58],
+           [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]]
+p m
+qr, tau = m.QR_decomp
+p qr.class
+p tau.class
+
+q, r = qr.unpack(tau)
+p q.class
+p r.class
+p q*r
+p q*q.trans   # Q: orthonormal
+
+

data/examples/linalg/QRPT.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+
+
+m = Matrix::alloc([0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58],
+		    [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85])
+qr, tau = m.QRPT_decomp
+p qr.class
+p tau.class
+
+b = Vector.alloc([1, 2, 3, 4])
+
+qr, tau, p = m.QRPT_decomp
+
+p Linalg::QRPT.solve(qr, tau, p, b)
+p Linalg::QRPT.solve(m, b)
+p m.QRPT_solve(b)
+p qr.QRPT_solve(tau, p, b)
+p m.QRPT_solve(b)
+
+bb = b.clone
+p Linalg::QRPT.solve(qr, tau, p, bb)
+bb = b.clone
+p Linalg::QRPT.solve(m, bb)
+bb = b.clone
+p m.QRPT_solve(b)
+bb = b.clone
+p qr.QRPT_solve(tau, p, bb)
+bb = b.clone
+p m.QRPT_solve(bb)
+bb = b.clone
+p qr.class
+p qr.solve(tau, p, bb)
+
+q, r, tau, p = m.QRPT_decomp2
+p q.class
+p r.class
+
+p Linalg::QRPT.QRsolve(q, r, p, b)
+
+bb = b.clone
+qr.svx(tau, p, bb)
+p bb
+bb = b.clone
+m.QRPT_svx(bb)
+p bb

data/examples/linalg/QR_solve.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+
+m = Matrix[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58],
+           [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]]
+qr, tau = m.QR_decomp
+
+b = Vector[1, 2, 3, 4]
+
+qr, tau = m.QR_decomp
+
+p Linalg::QR.solve(qr, tau, b)
+p Linalg::QR.solve(m, tau, b)
+p Linalg::QR.solve(m, b)
+begin
+  p Linalg::QR.solve(qr, b)    # Error
+rescue
+  puts("Error Linalg::QR.solve(qr, b)")
+end
+
+x = Vector.alloc(4)
+p m.QR_solve(b)
+p m.QR_solve(tau, b)
+p qr.QR_solve(tau, b)
+p qr.class
+p qr.solve(tau, b)
+
+m.QR_solve(b, x)
+p x
+m.QR_solve(tau, b, x)
+p x
+qr.QR_solve(tau, b, x)
+p x
+qr.solve(tau, b, x)
+p x
+
+bb = b.clone
+qr.svx(tau, bb)
+p bb
+bb = b.clone
+m.QR_svx(bb)
+p bb
+
+bb = b.clone
+Linalg::QR.svx(m, bb)
+p bb
+bb = b.clone
+Linalg::QR.svx(qr, tau, bb)
+p bb
+
+p m.QR_lssolve(b)
+p m.QR_lssolve(tau, b)
+p qr.QR_lssolve(tau, b)
+p qr.lssolve(tau, b)
+
+p Linalg::QR.lssolve(m, b)
+p Linalg::QR.lssolve(qr, tau, b)
+
+m3 = Matrix.alloc([5, 4, 1, 1], [4, 5, 1, 1], [1, 1, 4, 2], [1, 1, 2, 4])
+qr, tau = m3.QR_decomp
+p qr
+p tau
+
+q, r = qr.unpack(tau)
+p q
+p r
+p q*r
+
+q, r = Linalg::QR.unpack(qr, tau)
+p q
+p r
+p q*r
+
+qr, tau = m.QR_decomp
+q, r = Linalg::QR.unpack(qr, tau)
+p Linalg::QR.QRsolve(q, r, b)
+exit

data/examples/linalg/QR_solve_narray.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+
+m = NMatrix[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58],
+           [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]]
+qr, tau = Linalg::QR.decomp(m)
+
+p qr, tau
+
+b = NVector[1.0, 2, 3, 4]
+
+p Linalg::QR.solve(qr, tau, b)

data/examples/linalg/SV.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+A = GSL::Matrix[[3, 5, 2], [6, 2, 1], [4, 7, 3]]
+p A
+u, v, s = A.SV_decomp
+p u.class
+p v.class
+p s.class
+
+# u and v are orthonormal
+p u*u.trans
+p v*v.trans
+
+# Reconstruct the matrix A from u, v, and s.
+p u*GSL::Matrix.diagonal(s)*v.trans

data/examples/linalg/SV_narray.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+
+m = NMatrix[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58],
+            [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]]
+
+u, v, s = Linalg::SV.decomp(m)
+
+b = NArray[1.0, 2, 3, 4]
+
+p Linalg::SV.solve(u, v, s, b)

data/examples/linalg/SV_solve.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+
+m = Matrix[[-2, 1, 1], [1, -2, 1], [1, 1, -2], [-2, 1, 1]]
+u, v, s = m.SV_decomp
+p u.class
+p v.class
+p s.class
+
+m2 = Matrix[[5, 6, 8, 4], [6, 2, 4, 2], [8, 2, 3, 5], [1, 7, 2, 3]]
+u2, v2, s2 = m2.SV_decomp
+p u2
+p v2
+p s2
+
+m = GSL::Matrix[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58],
+                [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]]
+
+u, v, s = Linalg::SV.decomp_jacobi(m)
+
+b = [1, 2, 3, 4].to_gv
+
+p Linalg::SV.solve(u, v, s, b)
+p Linalg::SV.solve(u, v, s, [1, 2, 3, 4])
+
+puts "OK"
+p m.SV_solve(b)
+p Linalg::SV.solve(m, b)
+
+####
+A = Matrix[1..4, 2, 2]
+I = Matrix.identity(2)
+Ainv = A.inv
+
+u, v, s = A.SV_decomp
+sm = s.to_m_diagonal
+sinv = s.collect { |elm| 1.0/elm }.to_m_diagonal
+a = u*sm*v.trans
+ainv = v*sinv*u.trans
+p a == A
+p ainv == Ainv
+p (u.trans*u) == I
+p (v.trans*v) == I
+p A*v == u*sm
+p A.trans*u == v*sm
+
+
+

data/examples/linalg/chol.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+include Linalg
+
+m = Matrix.alloc([4, 2], [2, 3])
+c = Cholesky.decomp(m)
+p c.class
+p c
+
+b = Vector[1, 2]
+p Cholesky.solve(c, b)    # Expected [-0.125, 0.75]
+
+begin
+  m = Matrix::alloc([0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58],
+                  [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85])
+  
+  c = Cholesky.decomp(m)
+  b = [1, 2, 3, 4].to_gv
+  p Cholesky.solve(c, b)
+rescue
+  puts("Matrix must be positive definite.")
+end
+
+m = Matrix.pascal(6)
+c = m.cholesky_decomp
+a = c.lower
+p (a*a.trans) == m
+