gsl 1.12.109 → 1.14.5

data/examples/integration/qawo.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+require 'gsl'
+include GSL
+include Math
+
+f456 = Function.alloc { |x|
+  if x.zero?
+    val = 0.0
+  else
+    val = log(x)
+  end
+  val
+}
+
+exp_result = -1.281368483991674190E-01
+exp_abserr =  6.875028324415666248E-12
+
+table = [10.0*PI, 1.0, GSL::Integration::SINE, 1000]
+result = f456.qawo(0.0, [0.0, 1e-7], table)
+p result
+puts("exp_result: #{exp_result}")
+puts("exp_abserr: #{exp_abserr}")
+
+table = Integration::QAWO_Table.alloc(10.0*PI, 1.0, GSL::Integration::SINE, 1000)
+p f456.qawo(0.0, [0.0, 1e-7], table)
+p f456.qawo(0.0, table)
+
+p Integration.qawo(f456, 0.0, table)
+p Integration.qawo(f456, 0.0, [0.0, 1e-7], table)

data/examples/integration/qaws.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+require 'gsl'
+include GSL
+include Math
+
+f458 = Function.alloc { |x|
+  if x.zero?
+    val = 0.0
+  else
+    u = log(x)
+    v = 1.0 + u*u
+    val = 1.0/(v*v)
+  end
+  val
+}
+
+exp_result = -1.892751853489401670E-01
+exp_abserr =  1.129133712015747658E-08
+
+table = [0.0, 0.0, 1, 0]
+result = f458.qaws([0.0, 1.0], table, [0.0, 1e-7])
+p result
+puts("exp_result: #{exp_result}")
+puts("exp_abserr: #{exp_abserr}")
+
+table = Integration::QAWS_Table.alloc(0.0, 0.0, 1, 0)
+result = f458.qaws([0.0, 1.0], table, [0.0, 1e-7])
+p result
+
+p Integration.qaws(f458, [0.0, 1.0], table)

data/examples/integration/qng.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+include Math
+
+f = Function.alloc { |x| Math::sin(x)/x }
+
+p f.qng(0, 2.0*Math::PI)
+ 
+# Singular at x = 0
+f2 = Function.alloc { |x| exp(-x)/sqrt(x) }
+
+# This will fail...
+#p f2.qng(0, 1)
+
+p Integration.qng(f, [0, 2*Math::PI])
+

data/examples/interp/demo.gp

@@ -0,0 +1,20 @@
+set pointsize 2
+set multiplot
+set xlabel 'x'
+set ylabel 'y'
+set yrange [0:14]
+set size 0.5, 0.5
+set grid
+set origin 0, 0.5
+set key box
+plot 'points'
+
+set origin 0.5, 0.5
+plot 'points', 'linear.dat' w l, 'polynomial.dat' w l
+
+set origin 0, 0
+plot 'points', 'cspline.dat' w l, 'cspline_periodic.dat' w l
+
+set origin 0.5, 0
+plot 'points', 'akima.dat' w l, 'akima_periodic.dat' w l
+

data/examples/interp/demo.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+require("gsl")
+include Math
+include GSL
+
+n = 10
+xa = Vector[n]
+ya = Vector[n]
+for i in 0...n do
+  a = i.to_f
+  xa[i] = i + 0.5*sin(a)
+  ya[i] = i + cos(a*a)
+end
+
+def spline_compare(type, xa, ya, filename)
+  n = xa.size
+  spline = Spline.alloc(type, xa, ya)
+  p spline.name
+
+  xi = xa[0]
+  File.open(filename, "w") do |file|
+    while xi < xa[n-1]
+      yi = spline.eval(xi)
+      file.printf("%e %e\n", xi, yi)
+      xi += 0.01
+    end
+  end
+end
+
+types = ["linear", "polynomial", "cspline", "cspline_periodic", 
+         "akima", "akima_periodic"]
+         
+types.each do |t|
+  filename = t + ".dat"
+  spline_compare(t, xa, ya, filename)
+end
+
+#puts("6 interpolation types are examined.")
+#puts("Try \"gnuplot -persist spline-compare.gp\"")
+system("gnuplot -persist demo.gp")
+
+types.each do |t|
+  filename = t + ".dat"
+  File.delete(filename)
+end

data/examples/interp/interp.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+
+n = 10
+x = Vector[n]
+y = Vector[n]
+#x = NArray.float(n)
+#y = NArray.float(n)
+File.open("data0.dat", "w") do |f|
+  for i in 0...n do
+    a = i.to_f
+    x[i] = i + 0.5*Math::sin(a)
+    y[i] = i + Math::cos(a*a)
+    f.printf("%e %e\n", x[i], y[i])
+  end
+end
+
+interp = Interp.alloc("akima", n)
+interp.init(x, y)
+#interp = Interp.alloc(x, y)
+p interp.class
+p interp.name
+
+File.open("data1.dat", "w") do |f|
+  xi = x[0]
+  while xi < x[9]
+    yi = interp.eval(x, y, xi)
+    f.printf("%e %e\n", xi, yi)
+    xi += 0.01
+  end
+end
+
+system("graph -T X -g 3 -C -m -1 -S 4 data0.dat -S 1 data1.dat")
+File.delete("data0.dat")
+File.delete("data1.dat")
+

data/examples/interp/points

@@ -0,0 +1,10 @@
+0.000000e+00 1.000000e+00
+1.420735e+00 1.540302e+00
+2.454649e+00 1.346356e+00
+3.070560e+00 2.088870e+00
+3.621599e+00 3.042341e+00
+4.520538e+00 5.991203e+00
+5.860292e+00 5.872036e+00
+7.328493e+00 7.300593e+00
+8.494679e+00 8.391857e+00
+9.206059e+00 9.776686e+00

data/examples/interp/spline.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+
+x, y = Vector.filescan("points")
+
+#spline = Spline.alloc(Interp::CSPLINE, n)
+#spline.init(x, y)
+#spline = Spline.alloc(x, y, "cspline")
+#spline = Spline.alloc("cspline", x, y)
+spline = Spline.alloc(x, y)
+
+x2 = Vector.linspace(x[0], x[-1], 100)
+y2 = spline.eval(x2)
+
+graph([x, y], [x2, y2], "-C -g 3 -S 2")
+
+#p spline.name
+#p spline.min_size
+

data/examples/jacobi/deriv.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+if ARGV.size != 1
+  puts("Usage: integrate n\nn is the number of quadrature points.")
+  exit
+end
+
+Q = ARGV[0].to_i
+if Q < 1
+  puts("Usage: integrate n\nn is the number of quadrature points.")
+  exit
+end
+
+def fun(x)
+  Math::cos(3.0*x)
+end
+
+def dfun(x)
+  -3.0*Math::sin(3.0*x)
+end
+
+f = GSL::Vector.alloc(4*Q)
+
+quad = Jac::Quadrature.alloc(Q)
+quad.zwd(Jac::GJ, 0.0, 0.0)
+
+for i in 0...Q do
+  f[i] = fun(quad.x[i])
+end
+
+d = quad.differentiate(f)
+
+printf("X \t Derivative \t Error\n");
+
+for i in 0...Q do
+  printf("%f \t %f \t %e\n", quad.x[i], d[i], d[i] - dfun(quad.x[i]));
+end
+
+

data/examples/jacobi/integrate.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+if ARGV.size != 1
+  puts("Usage: integrate n\nn is the number of quadrature points.")
+  exit
+end
+
+Q = ARGV[0].to_i
+if Q < 1
+  puts("Usage: integrate n\nn is the number of quadrature points.")
+  exit
+end
+
+def fun(x)
+  Math::cos(3.0*x)
+end
+
+f = GSL::Vector.alloc(4*Q)
+
+quad = Jac::Quadrature.alloc(Q)
+quad.zwd(Jac::GJ, 0.0, 0.0)
+
+for i in 0...Q do
+  f[i] = fun(quad.x[i])
+end
+
+integr = quad.integrate(f)
+exact = 2.0/3.0*Math::sin(3.0)
+
+printf("Integral of cos(3x) from -1 to 1: %f\n", exact);
+printf("jac_integrate result: %f\n", integr)
+printf("Error: %e\n", integr - exact);
+

data/examples/jacobi/interp.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+if ARGV.size != 1
+  puts("Usage: integrate n\nn is the number of quadrature points.")
+  exit
+end
+
+Q = ARGV[0].to_i
+if Q < 1
+  puts("Usage: integrate n\nn is the number of quadrature points.")
+  exit
+end
+
+def fun(x)
+  Math::cos(3.0*x)
+end
+
+def dfun(x)
+  -3.0*Math::sin(3.0*x)
+end
+
+f = GSL::Vector.alloc(4*Q)
+xp = GSL::Vector.linspace(0.1, 0.9, 9)
+
+quad = Jac::Quadrature.alloc(Q)
+quad.zwd(Jac::GJ, 0.0, 0.0)
+quad.interpmat_alloc(xp)
+
+for i in 0...Q do
+  f[i] = fun(quad.x[i])
+end
+
+fout = quad.interpolate(f)
+
+printf("X \t f(x) \t Error\n");
+
+for i in 0...xp.size do
+  printf("%f \t %f \t %e\n", xp[i], fout[i], fout[i] - fun(xp[i]));
+end
+
+quad.interpmat_free
+

data/examples/jacobi/jacobi.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+p Jac::jacobi_P1(0.2, 0.2, 0.5)
+
+x = GSL::Vector.linspace(-1, 1, 6)
+p Jac::jacobi(x, 1, 0.2, 0.5)
+
+p Jac::jacobi_P1(x, 0.2, 0.5)
+
+p Jac::jacobi_zeros(6, 0.2, 0.5)

data/examples/linalg/HH.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+include GSL::Linalg
+
+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]]
+
+b = Vector.alloc(1, 2, 3, 4)
+p HH.solve(m, b)
+
+p m.HH_solve(b)
+
+m.HH_svx(b)
+p b

data/examples/linalg/HH_narray.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL::Linalg
+
+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]]
+
+b = NVector[1.0, 2, 3, 4]
+p HH.solve(m, b)
+p b
+HH.svx(m, b)
+p b
+

data/examples/linalg/LQ_solve.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+
+m = GSL::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.LQ_decomp
+
+b = Vector[1, 2, 3, 4]
+
+lq, tau = m.LQ_decomp
+
+p Linalg::LQ.solve_T(lq, tau, b)
+p Linalg::LQ.solve_T(m, tau, b)
+p Linalg::LQ.solve_T(m, b)
+
+begin
+  p Linalg::LQ.solve_T(lq, b)    # Error
+rescue
+  puts("Error Linalg::LQ.solve_T(lq, b)")
+end
+
+x = Vector.alloc(4)
+p m.LQ_solve_T(b)
+p m.LQ_solve_T(tau, b)
+p lq.LQ_solve_T(tau, b)
+p lq.class
+p lq.solve_T(tau, b)
+
+m.LQ_solve_T(b, x)
+p x
+m.LQ_solve_T(tau, b, x)
+p x
+lq.LQ_solve_T(tau, b, x)
+p x
+lq.solve_T(tau, b, x)
+p x
+
+bb = b.clone
+lq.svx_T(tau, bb)
+p bb
+bb = b.clone
+m.LQ_svx_T(bb)
+p bb
+
+bb = b.clone
+Linalg::LQ.svx_T(m, bb)
+p bb
+bb = b.clone
+Linalg::LQ.svx_T(lq, tau, bb)
+p bb
+
+p m.LQ_lssolve_T(b)
+p m.LQ_lssolve_T(tau, b)
+p lq.LQ_lssolve_T(tau, b)
+p lq.lssolve_T(tau, b)
+
+p Linalg::LQ.lssolve_T(m, b)
+p Linalg::LQ.lssolve_T(lq, tau, b)
+
+m3 = Matrix.alloc([5, 4, 1, 1], [4, 5, 1, 1], [1, 1, 4, 2], [1, 1, 2, 4])
+m3.transpose!
+lq, tau = m3.LQ_decomp
+
+q, l = lq.unpack(tau)
+
+q, l = Linalg::LQ.unpack(lq, tau)
+
+lq, tau = m.LQ_decomp
+q, l = Linalg::LQ.unpack(lq, tau)
+p Linalg::LQ.LQsolve_T(q, l, b)
+