rb-gsl 1.15.3.1

data/examples/random/rngextra.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+r1 = GSL::Rng.alloc(GSL::Rng::RNGEXTRA_RNG1)
+p r1.name
+p r1.uniform
+p r1.gaussian
+
+r2 = GSL::Rng.alloc("rngextra_rng2")
+p r2.name
+p r2.get
+p r2.get
+p r2.uniform
+p r2.poisson(3)

data/examples/roots/bisection.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require("gsl")
+solver = GSL::Root::FSolver.alloc(GSL::Root::FSolver::BISECTION)
+puts "Using #{solver.name} method"
+f = GSL::Function.alloc { |x, params|
+  a = params[0];  b = params[1];  c = params[2]
+  (a*x + b)*x + c
+}
+f.set_params(1, 0, -5)
+expected = Math::sqrt(5.0)
+printf("%5s [%9s, %9s] %9s %10s %9s\n", 
+       "iter", "lower", "upper", "root",  "err", "err(est)")
+solver.set(f, 0.0, 5.0)
+iter = 0
+status = nil
+while status != GSL::SUCCESS
+  iter += 1
+  status = solver.iterate
+  r = solver.root;  xl = solver.x_lower;  xu = solver.x_upper
+  status = solver.test_interval(0, 0.001)
+  if status == GSL::SUCCESS; printf("Converged:\n"); end
+  printf("%5d [%.7f, %.7f] %.7f %+.7f %.7f\n",
+         iter, xl, xu, r, r - expected, xu - xl)
+end
+

data/examples/roots/brent.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+require("gsl")
+include Math
+
+#solver = GSL::Root::FSolver.alloc(GSL::Root::FSolver::BISECTION)
+#solver = GSL::Root::FSolver.alloc("falsepos")
+#solver = GSL::Root::FSolver.alloc("brent")
+solver = GSL::Root::FSolver.alloc(GSL::Root::FSolver::BRENT)
+puts "using #{solver.name} method"
+
+f = GSL::Function.alloc { |x, params|
+  a = params[0]
+  b = params[1]
+  c = params[2]
+  (a*x + b)*x + c
+}
+
+f.set_params(1, 0, -5)
+expected = sqrt(5.0)
+
+printf("%5s [%9s, %9s] %9s %10s %9s\n",
+          "iter", "lower", "upper", "root", 
+          "err", "err(est)")
+
+solver.set(f, 0.0, 5.0)
+iter = 0
+status = nil
+while status != GSL::SUCCESS
+  iter += 1
+  status = solver.iterate
+  r = solver.root
+  xl = solver.x_lower
+  xu = solver.x_upper
+  status = solver.test_interval(0, 0.001)
+
+  if status == GSL::SUCCESS
+    printf("Converged:\n")
+  end
+  printf("%5d [%.7f, %.7f] %.7f %+.7f %.7f\n",
+         iter, xl, xu, r, r - expected, xu - xl)
+end
+
+p f.fsolve(0, 5)

data/examples/roots/demo.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+require("gsl")
+solver = GSL::Root::FSolver.alloc(GSL::Root::FSolver::BISECTION)
+f = GSL::Function.alloc { |x, params|
+  a = params[0]; b = params[1]; c = params[2]
+  (a*x + b)*x + c
+}
+f.set_params(1, 0, -5)
+expected = Math::sqrt(5.0)
+printf("%5s [%9s, %9s] %9s %10s %9s\n", "iter", 
+       "lower", "upper", "root", "err", "err(est)")
+solver.set(f, 0.0, 5.0)
+iter = 0; status = nil
+IO.popen("graph -T X -C -g 3 -X Iterations -Y 'Root'\
+         --toggle-rotate-y-label\
+         -L 'x^2 - 5 = 0, #{solver.name}' -I e -S 4", "w") do |io|
+  while status != GSL::SUCCESS
+    iter += 1
+    status = solver.iterate
+    r = solver.root
+    xl = solver.x_lower; xu = solver.x_upper
+    status = solver.test_interval(0, 0.001)
+    if status == GSL::SUCCESS; printf("Converged:\n"); end
+    printf("%5d [%.7f, %.7f] %.7f %+.7f %.7f\n",
+           iter, xl, xu, r, r - expected, xu - xl)
+    io.printf("%d %e %e\n", iter, r, (xu-xl)/2)
+  end
+end
+
+

data/examples/roots/newton.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+require("gsl")
+include Math
+
+f = Proc.new { |x, params| 
+  a = params[0]
+  b = params[1]
+  c = params[2]
+  (a*x + b)*x + c
+}
+
+df = Proc.new { |x, params| 
+  a = params[0]
+  b = params[1]
+  2.0*a*x + b
+}
+
+expected = sqrt(5.0)
+x = 5.0
+
+function_fdf = GSL::Function_fdf.alloc(f, df)
+function_fdf.set_params([1.0, 0, -5])
+
+solver = GSL::Root::FdfSolver.alloc(GSL::Root::FdfSolver::NEWTON)
+puts "using #{solver.name} method"
+
+solver.set(function_fdf, x)
+
+printf("%-5s %10s %10s %10s\n",
+          "iter", "root", "err", "err(est)")
+iter = 0
+status = nil
+while status != GSL::SUCCESS
+  iter += 1
+  status = solver.iterate
+  x0 = x
+  x = solver.root
+  status = GSL::Root::test_delta(x, x0, 0, 1e-3)
+
+  if status == GSL::SUCCESS
+    printf("Converged:\n")
+  end
+  printf("%5d %10.7f %+10.7f %10.7f\n",
+         iter, x, x - expected, x - x0)
+
+end

data/examples/roots/recombination.gp

@@ -0,0 +1,12 @@
+set logscale y
+set xtics nomirror
+set yrange [1e-5:1e1]
+set xrange [2100:900]
+set x2range [2100*2.725:900*2.725]
+set x2tics
+set xlabel '1 + z (Redshift)'
+set ylabel 'Fractional ionization'
+set x2label 'Temperature of the Universe [K]'
+set grid
+plot 'recombination.dat' u 2:3 title '' w l lw 3, 1 title ''
+ 

data/examples/roots/recombination.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+#  This solves the Saha's equation, to investigate
+#  'recombination' of hot cosmic plasma.
+require("gsl")
+include GSL
+include GSL::CONST::CGSM
+include Math
+
+KB =  BOLTZMANN
+HBAR = PLANCKS_CONSTANT_HBAR
+
+class Recombination
+  def initialize(t0, bdensity, eion)
+    @t = 2500
+    @tCMB = t0                   # Present temperature of CMB [K]
+    @n0 = bdensity/MASS_PROTON   # Barion number density [cm-3]
+    @eion = eion*ELECTRON_VOLT   # Hydrogen ionization potential [eV]
+    @saha_equation = Function.alloc { |x|   # x: fractional ionization
+      n = @n0*pow_3(@t/@tCMB)
+      tmp1 = pow(MASS_ELECTRON*KB*@t/2.0/PI/HBAR/HBAR, 1.5)
+      tmp2 = exp(-@eion/KB/@t)
+      x*x - (1.0 - x)*tmp1*tmp2/n
+    }
+  end
+
+  def zplus1()
+    @t/@tCMB
+  end
+
+  attr_accessor :t
+  attr_reader :saha_equation
+end
+
+###########################
+## Cosmological parameter
+TCMB = 2.725        # Temperature of cosmic microwave background at present [K]
+BDENSITY = 1e-29    # Barion density [g cm-3]
+EIONIZE = 13.6      # Hydrogen ionization potential [eV]
+unv = Recombination.new(TCMB, BDENSITY, EIONIZE)
+
+# FSolver
+solver = Root::FSolver.alloc(Root::FSolver::BRENT)
+
+TMIN = 2500
+TMAX = 6500
+
+begin
+  file = File.open("recombination.dat", "w")
+  t = TMIN
+  while t < TMAX
+    unv.t = t  # Temperature
+    x, iter, status = solver.solve(unv.saha_equation, [1e-8, 1.0], [0, 1e-4])
+    file.printf("%e %e %e\n", unv.t, unv.zplus1, x)
+    t *= 1.01
+  end
+ensure
+  file.close
+end
+system("gnuplot -persist recombination.gp")
+File.delete("recombination.dat")
+#puts("Try \"gnuplot -persist recombination.gp\"")

data/examples/roots/steffenson.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+require("gsl")
+include Math
+
+def f_to_solve(x)
+  x*x - 5.0
+end
+
+def df_to_solve(x)
+  2*x
+end
+
+f = Proc.new { |x|
+  f_to_solve(x)
+}
+
+df = Proc.new { |x|
+  df_to_solve(x)
+}
+
+expected = sqrt(5.0)
+x = 5.0
+
+function_fdf = GSL::Function_fdf.alloc(f, df)
+
+solver = GSL::Root::FdfSolver.alloc(GSL::Root::FdfSolver::STEFFENSON)
+puts "using #{solver.name} method"
+
+solver.set(function_fdf, x)
+
+printf("%-5s %10s %10s %10s\n",
+          "iter", "root", "err", "err(est)")
+iter = 0
+status = nil
+while status != GSL::SUCCESS
+  iter += 1
+  status = solver.iterate
+  x0 = x
+  x = solver.root
+  status = GSL::Root::test_delta(x, x0, 0, 1e-3)
+
+  if status == GSL::SUCCESS
+    printf("Converged:\n")
+  end
+  printf("%5d %10.7f %+10.7f %10.7f\n",
+         iter, x, x - expected, x - x0)
+
+end

data/examples/sf/ShiChi.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require("gsl")
+x = GSL::Vector.linspace(0.01, 12, 100)
+s = GSL::Sf::Shi(x)   # s and c are GSL::Vector
+c = GSL::Sf::Chi(x)
+GSL::Vector.graph(x, s, c, "-T X -C -g 3 -y -1.5 2 -L 'Hyperbolic integrals Shi(x), Chi(x)'")

data/examples/sf/SiCi.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require("gsl")
+x = GSL::Vector.linspace(0.1, 12, 100)
+s = GSL::Sf::Si(x) - Math::PI/2.0
+c = GSL::Sf::Ci(x)
+GSL::Vector.graph(x, s, c, "-T X -C -g 3 -y -1.5 1 -L 'Red: Sine integral, Green: Cosine integral'")

data/examples/sf/airy_Ai.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require("gsl")
+x = GSL::Vector.linspace(-10, 10, 100)
+a = GSL::Sf::airy_Ai(x)
+a.graph(x, "-C -g 3 -L 'GSL::Sf::airy_Ai(x)'")
+
+
+

data/examples/sf/airy_Bi.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require("gsl")
+x = GSL::Vector.linspace(-1, 4, 50)
+a = GSL::Sf::airy_Bi(x)
+a.graph(x, "-C -g 3 -L 'Sf::airy_Bi(x)'")
+
+
+

data/examples/sf/bessel_IK.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+require("gsl")
+n = 100
+x = GSL::Vector.linspace(0.01, 4, n)
+I0 = GSL::Sf::bessel_I0(x)
+I1 = GSL::Sf::bessel_I1(x)
+I2 = GSL::Sf::bessel_In(2, x)
+
+y0 = GSL::Sf::bessel_K0(x)
+y1 = GSL::Sf::bessel_K1(x)
+y2 = GSL::Sf::bessel_Kn(2, x)
+GSL::Vector.graph(x, I0, I1, I2, y0, y1, y2, "-T X -C -g 3 -y 0 6 -X x -L 'Bessel functions I0, I1, I2, K0, K1, K2'")

data/examples/sf/bessel_JY.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require("gsl")
+n = 100
+x = GSL::Vector.linspace(0.01, 20, n)
+J0 = GSL::Sf::bessel_J0(x)
+J1 = GSL::Sf::bessel_J1(x)
+J2 = GSL::Sf::bessel_Jn(2, x)
+
+y0 = GSL::Sf::bessel_Y0(x)
+y1 = GSL::Sf::bessel_Y1(x)
+y2 = GSL::Sf::bessel_Yn(2, x)
+
+GSL::Vector.graph(x, J0, J1, J2, y0, y1, y2, "-T X -C -g 3 -y -2 1.1 -X x -L 'Bessel functions J0, J1, J2, Y0, Y1, Y2'")

data/examples/sf/beta_inc.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require("gsl")
+n = 50
+x = GSL::Vector.linspace(0.01, 1, n)
+y1 = GSL::Sf::beta_inc(0.5, 5.0, x)
+y2 = GSL::Sf::beta_inc(1.0, 3.0, x)
+y3 = GSL::Sf::beta_inc(8.0, 10.0, x)
+y4 = GSL::Sf::beta_inc(5.0, 0.5, x)
+GSL::Vector.graph([x, y1], [x, y2], [x, y3], [x, y4], "-T X -C -g 3 -y 0 1.1 -X x -L 'Incomplete beta functions'")

data/examples/sf/clausen.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require("gsl")
+x = GSL::Vector.linspace(0, 20, 100)
+a = GSL::Sf::clausen(x)
+GSL::graph(x, a, "-C -g 3 -L 'Sf::clausen(x)'")
+

data/examples/sf/dawson.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require("gsl")
+x = GSL::Vector.linspace(0, 20, 100)
+y = GSL::Sf::dawson(x)
+y.graph(x, "-T X -C -g 3 -L 'Dawson integral'")

data/examples/sf/debye.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require("gsl")
+n = 50
+x = GSL::Vector.linspace(0, 20, n)
+y1 = GSL::Sf::debye_1(x)
+y2 = GSL::Sf::debye_2(x)
+y3 = GSL::Sf::debye_3(x)
+y4 = GSL::Sf::debye_4(x)
+GSL::Vector.graph(x, y1, y2, y3, y4, "-T X -C -g 3 -X x -L 'Debye functions'")

data/examples/sf/dilog.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require("gsl")
+n = 100
+x = GSL::Vector.linspace(0, 20, n)
+y = GSL::Sf::dilog(x)
+y.graph(x, "-T X -C -g 3 -X x -L 'Dilogarithm'")

data/examples/sf/ellint.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require("gsl")
+x = GSL::Vector.linspace(0, 0.9, 100)
+k = GSL::Sf::ellint_Kcomp(x)
+e = GSL::Sf::ellint_Ecomp(x)
+GSL::Vector.graph(x, k, e, "-T X -g 3 -C -L 'Red: Kcomp(x), Green: Ecomp(x)'")

data/examples/sf/expint.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require("gsl")
+n = 100
+x = GSL::Vector.linspace(0.01, 2, n)
+y1 = GSL::Sf::expint_E1(x)
+y2 = GSL::Sf::expint_E2(x)
+yi = GSL::Sf::expint_Ei(x)
+GSL::Vector.graph(x, y1, y2, yi, "-T X -C -g 3 -X x -Y 'E(x)' --toggle-rotate-y-label -L 'Exponential integral E1, E2, Ei'")

data/examples/sf/fermi.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+require("gsl")
+n = 100
+x = GSL::Vector.linspace(0, 10, n)
+m1 = GSL::Sf::fermi_dirac_m1(x)
+IO.popen("graph -T X -C -g 3 -X x -L 'Fermi-Dirac function'", "w") do |io|
+  for i in 0...n do
+    io.printf("%e %e\n", x[i], m1[i])
+  end
+end

data/examples/sf/gamma_inc_P.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require("gsl")
+n = 50
+x = GSL::Vector.linspace(0.01, 14, n)
+y05 = GSL::Sf::gamma_inc_P(0.5, x)
+y1 = GSL::Sf::gamma_inc_P(1, x)
+y3 = GSL::Sf::gamma_inc_P(3, x)
+y10 = GSL::Sf::gamma_inc_P(10, x)
+GSL::Vector.graph(x, y05, y1, y3, y10, "-T X -C -g 3 -y 0 1.1 -L 'Incomplete gamma functions'")

data/examples/sf/gegenbauer.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require("gsl")
+n = 100
+x = GSL::Vector.linspace(0, 5, n)
+y1 = GSL::Sf::gegenpoly_1(0, x)
+y2 = GSL::Sf::gegenpoly_2(0, x)
+y3 = GSL::Sf::gegenpoly_3(0, x)
+GSL::Vector.graph(x, y1, y2, y3, "-T X -C -g 3 -X x -L 'Gegenbauer functions'")