gsl 1.12.109 → 1.14.5

data/examples/odeiv/demo.gp

@@ -0,0 +1,24 @@
+set multiplot
+set grid
+set size 0.33, 0.33
+
+set origin 0, 0.66
+plot 'rk2.dat' title 'rk2', exp(-2*x)
+set origin 0.33, 0.66
+plot 'rk4.dat' title 'rk4', exp(-2*x)
+set origin 0.66, 0.66
+plot 'rkf45.dat' title 'rkf45', exp(-2*x)
+set origin 0, 0.33
+plot 'rkck.dat' title 'rkck', exp(-2*x)
+set origin 0.33, 0.33
+plot 'rk8pd.dat' title 'rk8pd', exp(-2*x)
+set origin 0.66, 0.33
+plot 'rk2imp.dat' title 'rk2imp', exp(-2*x)
+set origin 0, 0
+plot 'rk4imp.dat' title 'rk4imp', exp(-2*x)
+set origin 0.33, 0
+plot 'bsimp.dat' title 'bsimp', exp(-2*x)
+set origin 0.66, 0
+plot 'gear1.dat' title 'gear1', exp(-2*x)
+#set origin 0.5, 0
+#plot 'gear2.dat' title 'gear2', exp(-2*x)

data/examples/odeiv/demo.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+# Solve 
+#   dydt = -2y     ---> y(t) = exp(-2t)
+
+require("gsl")
+include GSL::Odeiv
+
+dim = 1
+
+PARAM = 2.0
+
+func = Proc.new { |t, y, dydt, param|
+  dydt[0] = -param*y[0]
+}
+
+jac = Proc.new { |t, y, dfdy, dfdt, param|
+  dfdy = -param
+  dfdt[0] = 0.0
+}
+
+def odeiv_compare_algorithm(solver, steptype, t0, tend, h0, y0, outfile)
+  t = t0*1.0
+  h = h0*1.0
+  y = GSL::Vector.alloc([y0])
+  s = Step.alloc(steptype, solver.dim)
+  solver.set_step(s)
+  solver.evolve.reset
+#  p solver.params
+
+  i = 0
+  file = File.open(outfile, "w")
+  while t < tend
+    t, h, status = solver.apply(t, tend, h, y)
+    break if status != GSL::SUCCESS
+    file.printf("%.5e %.5e %.5e\n", t, y[0], h)
+    i += 1
+  end
+  file.close
+  return i
+end
+
+if GSL::VERSION >= "1.5.90"
+  ALGORITHMS = ["rk2", "rk4", "rkf45", "rkck", "rk8pd", "rk2imp", "rk4imp", 
+                "bsimp", "gear1", "gear2", "rk2simp"]
+  gpfile = "demo2.gp"
+else
+  ALGORITHMS = ["rk2", "rk4", "rkf45", "rkck", "rk8pd", "rk2imp", "rk4imp", 
+                "bsimp", "gear1", "gear2"]
+  gpfile = "demo.gp"
+end
+
+solver = Solver.alloc(Step::RKF45, [1e-6, 0.0], func, jac, dim)
+solver.set_params(PARAM)
+
+puts("Solve dydt = -2y, y[0] = 1")
+puts("y(t) = exp(-2t)\n\n")
+ALGORITHMS.each do |alg|
+  outfile = alg + ".dat"
+  t0, tend, h0, y0 = 0.0, 3.0, 1e-6, 1.0
+  i = odeiv_compare_algorithm(solver, alg, t0, tend, h0, y0, outfile)
+  printf("%7s: Iteration %5d\n", alg, i)
+end
+
+system("gnuplot -persist #{gpfile}")
+
+ALGORITHMS.each do |alg|
+  outfile = alg + ".dat"
+  File.delete(outfile)
+end

data/examples/odeiv/demo2.gp

@@ -0,0 +1,26 @@
+set multiplot
+set grid
+set size 0.33, 0.25
+
+set origin 0, 0.75
+plot 'rk2.dat' title 'rk2', exp(-2*x)
+set origin 0.33, 0.75
+plot 'rk4.dat' title 'rk4', exp(-2*x)
+set origin 0.66, 0.75
+plot 'rkf45.dat' title 'rkf45', exp(-2*x)
+set origin 0, 0.5
+plot 'rkck.dat' title 'rkck', exp(-2*x)
+set origin 0.33, 0.5
+plot 'rk8pd.dat' title 'rk8pd', exp(-2*x)
+set origin 0.66, 0.5
+plot 'rk2imp.dat' title 'rk2imp', exp(-2*x)
+set origin 0, 0.25
+plot 'rk4imp.dat' title 'rk4imp', exp(-2*x)
+set origin 0.33, 0.25
+plot 'bsimp.dat' title 'bsimp', exp(-2*x)
+set origin 0.66, 0.25
+plot 'gear1.dat' title 'gear1', exp(-2*x)
+set origin 0, 0
+plot 'gear2.dat' title 'gear2', exp(-2*x)
+set origin 0.33, 0
+plot 'rk2simp.dat' title 'rk2simp', exp(-2*x)

data/examples/odeiv/duffing.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+#
+# Duffing equation
+#
+require("gsl")
+
+dim = 2
+
+# x'' + a x' + bx^3 = f cos(omega t)
+#
+duffing = Proc.new { |t, x, dxdt, params|
+  a = params[0]; b = params[1]
+  omega = params[2]; f = params[3]
+  dxdt[0] = x[1]
+  dxdt[1] = -a*x[1] - b*GSL::pow_3(x[0]) + f*Math::cos(omega*t)
+}
+
+solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RK8PD, [1e-6, 0.0], duffing, dim)
+
+a = 0.05
+b = 1.0
+omega = 1.0
+f = 5.0
+solver.set_params(a, b, omega, f)
+
+t = 0.0      # initial position
+tend = 200
+hstart = 2.0*Math::PI/1000
+
+h = hstart*1.0
+
+# Initial conditions, at x = 0
+# P21(0) = 0, P21'(0) = 3
+x = GSL::Vector.alloc(0.0, 0.0)
+count = 0
+IO.popen("graph -T X -C -g 3", "w") do |io|
+  while t < tend
+    t, h, status = solver.apply(t, tend, h, x)
+    if count%2 == 0
+      io.printf("%g %g\n", t, x[0])
+    end
+    break if status != GSL::SUCCESS
+    count += 1
+  end
+end

data/examples/odeiv/frei1.rb

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby
+#  Solve Schroedinger equation
+#
+#  This example is taken from frei1.cpp 
+#  in "Numerische Physik" p201-204 (Springer),
+#  which simulates the time evolution of a probability density.
+#
+#  Name: frei1.cpp
+#  Zweck: Simuliert ein quantenmechanisches freies Teilchen 
+#  Gleichung: Schroedingergleichung ohne Potential verwendete 
+#  Bibiliothek: GSL
+#
+#  Reference:
+#    "Numerische Physik", by Harald Wiedemann, Springer (2004)
+#    ISBN: 3-540-40774-X
+#    http://www.springeronline.com/sgw/cda/frontpage/0,10735,1-102-22-22345455-0,00.html
+
+require("gsl")
+
+#NMAX = 8192
+NMAX = 256
+
+# The wave equation: 
+# calculate time derivative of the wave function.
+# The second spatial derivative is approximated by
+#   d2_psi/dx2 ~ (psi[n+1] - 2*psi[n] + pxi[n-1])/(dx*dx)
+# See "Numerische Physik" p204, Eq. (5.47).
+#
+# psi(x), dpsi_dt(x): Complex-valued wavefunction, expressed as
+#
+#   0              NMAX             2*NMAX
+#  |-----------------|-----------------|
+#          Real           Imaginary
+#
+f = Proc.new { |t, psi, dpsi_dt|
+  dx2 = $dx*$dx
+
+# Real part
+  for n in 1...(NMAX-1) do
+    dpsi_dt[n] = -(psi[NMAX+n+1]+psi[NMAX+n-1]-2*psi[NMAX+n])/dx2
+  end
+  dpsi_dt[0] = -(psi[NMAX+1]+psi[2*NMAX-1]-2*psi[NMAX])/dx2
+  dpsi_dt[NMAX-1] = -(psi[NMAX]+psi[2*NMAX-2]-2*psi[2*NMAX-1])/dx2
+
+#  Imaginary part
+  for n in (NMAX+1)...(2*NMAX-1) do
+    dpsi_dt[n] = +(psi[n+1-NMAX]+psi[n-1-NMAX]-2*psi[n-NMAX])/dx2
+  end
+  dpsi_dt[NMAX] = +(psi[1]+psi[NMAX-1]-2*psi[0])/dx2
+  dpsi_dt[2*NMAX-1] = +(psi[0]+psi[NMAX-2]-2*psi[NMAX-1])/dx2
+}
+
+psi = GSL::Vector[2*NMAX]
+dpsi_dt = GSL::Vector[2*NMAX]
+
+$dx = 0.1
+dt = 0.1
+n_out = 20
+alpha = 1
+p_0 = -0.5
+atol = 1e-4
+rtol = 0.0
+
+h = 1.0e-4
+
+dx2 = $dx*$dx
+sum = 0.0
+for n in 0...NMAX do
+  x = (n-NMAX/2) * $dx
+  psi[n] = Math::exp(-GSL::pow_2(x/alpha)/2)
+  sum += GSL::pow_2(psi[n]) 
+end
+sum = 1.0/Math::sqrt(sum)
+
+for n in 0...NMAX do
+  x = (n-NMAX/2) * $dx
+  psi[n+NMAX] = -psi[n] * sum * Math::sin(p_0*x) # Imaginaerteil
+  psi[n] = psi[n] * sum * Math::cos(p_0*x)       # Realteil
+end
+
+IO.popen("graph -T X -C -g 3", "w") do |io|
+  for n1 in 0...NMAX do
+    x = (n1-NMAX/2) * $dx
+    io.printf("%e %e\n", x, Math::sqrt(GSL::pow_2(psi[n1]) + GSL::pow_2(psi[n1+NMAX])))
+  end
+  io.printf("\n")
+
+  step = GSL::Odeiv::Step.alloc(GSL::Odeiv::Step::RKF45, 2*NMAX)
+  c = GSL::Odeiv::Control.y_new(atol, rtol)
+  evolve = GSL::Odeiv::Evolve.alloc(2*NMAX)
+  sys = GSL::Odeiv::System.alloc(f, 2*NMAX)
+  
+  t = 0.0
+  for n in 1..n_out do
+    t1 = n*dt
+    STDOUT.printf("t = %2.1f (%2d/%2d)\n", t1-dt, n, n_out)
+    while t < t1 
+      t, h, status = evolve.apply(c, step, sys, t, t1, h, psi)
+      break if status != GSL::SUCCESS
+    end
+    if n%10 == 0
+      for n1 in 0...NMAX do
+        x = (n1-NMAX/2) * $dx
+        io.printf("%e %e\n", x, Math::sqrt(GSL::pow_2(psi[n1]) + GSL::pow_2(psi[n1+NMAX])))
+      end
+      io.printf("\n")
+    end
+  end
+end

data/examples/odeiv/frei2.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+# This example is taken from frei2.cpp 
+# in "Numerische Physik" p205-206 (Springer).
+#
+# Reference:
+#   "Numerische Physik", by Harald Wiedemann, Springer (2004)
+#   ISBN: 3-540-40774-X
+#   http://www.springeronline.com/sgw/cda/frontpage/0,10735,1-102-22-22345455-0,00.html
+
+require("gsl")
+
+#NMAX = 8192
+NMAX = 256
+
+psi = GSL::Vector::Complex[NMAX]
+
+dx = 0.1
+dt = 0.1
+n_out = 20
+alpha = 1
+p_0 = -0.5
+
+dp = 2*Math::PI/dx/NMAX
+
+sum = 0.0
+for n in 0...NMAX
+  x = (n-NMAX/2) * dx
+  psi[n] = Math::exp(-GSL::pow_2(x/alpha)/2)
+  sum += GSL::pow_2(psi[n].re);
+end
+sum = 1.0/Math::sqrt(sum)
+
+for n in 0...NMAX
+  x = (n-NMAX/2) * dx
+  psi[n] *= GSL::Complex[
+    sum * Math::cos(p_0*x),
+    -sum * Math::sin(p_0*x) # Imaginaerteil
+  ]
+end
+
+IO.popen("graph -T X -C -g 3", "w") do |io|
+  psi_p = psi.duplicate
+  for n1 in 0...NMAX do
+    x = (n1-NMAX/2) * dx
+    io.printf("%e %e\n", x, psi[n1].abs)
+  end
+  io.printf("\n")
+  
+  psi_p.radix2_forward!
+  
+  
+  t = 0.0
+  for n in 1..n_out do
+    t1 = n*dt
+    STDOUT.printf("t = %2.1f (%2d/%2d)\n", t1, n, n_out)
+    for n1 in 0...(NMAX/2) do
+      pp = n1*dp
+      arg = GSL::pow_2(pp)*t1/2
+      psi[n1] = psi_p[n1] * GSL::Complex.polar(1, -arg)
+    end
+    for n1 in (NMAX/2)...NMAX do
+      pp = (n1-NMAX)*dp
+      arg = GSL::pow_2(pp)*t1/2
+      psi[n1] = psi_p[n1] * GSL::Complex.polar(1, -arg)
+    end
+    psi.radix2_inverse!
+    if n%10 == 0
+      for n1 in 0...NMAX do
+        x = (n1-NMAX/2) * dx
+        io.printf("%e %e\n", x, psi[n1].abs)
+      end
+      io.printf("\n")
+    end
+  end
+end
+

data/examples/odeiv/legendre.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+#
+# Solve Legendre's differential equation
+#   l = 2, m = 1
+require("gsl")
+dim = 2
+
+fleg = Proc.new { |x, y, f, params|
+  l = params[0]
+  m = params[1]
+  f[0] = y[1]
+  f[1] = 2.0*x/(1-x*x)*y[1] - (l*(l + 1) - m*m/(1-x*x))/(1-x*x)*y[0]
+}
+
+solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RKF45, [1e-6, 0.0], fleg, dim)
+
+# P21
+l = 2
+m = 1
+solver.set_params(l, m)
+
+x = 0.0      # initial position
+xend = 0.999
+hstart = 1e-8
+
+h = hstart*1.0
+
+# Initial conditions, at x = 0
+# P21(0) = 0, P21'(0) = 3
+y = GSL::Vector.alloc(0.0, 3.0)
+
+File.open("legode.dat", "w") do |f|
+  while x < xend
+    x, h, status = solver.apply(x, xend, h, y)
+    f.printf("%g %g\n", x, y[0])
+    break if status != GSL::SUCCESS
+  end
+end
+
+File.open("plm.dat", "w") do |f|
+  x = 0.0
+  while x < xend
+    plmx = GSL::Sf::legendre_Plm(l, m, x).abs
+    f.printf("%g %g\n", x, plmx)
+    x += 0.01
+  end
+end
+
+system("graph -T X -C -g 3 -X x -Y 'P21(x)' --toggle-rotate-y-label --title-font-size 0.05 -L 'Red: expect, Green: RKF45' -m 1 plm.dat -m -2 -S 4 legode.dat")
+File.delete("legode.dat")
+File.delete("plm.dat")
+

data/examples/odeiv/odeiv.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+require("gsl")
+dim = 2
+func = Proc.new { |t, y, dydt, mu|
+  dydt[0] = y[1]
+  dydt[1] = -y[0] - mu*y[1]*(y[0]*y[0] - 1.0)
+}
+step = GSL::Odeiv::Step.alloc(GSL::Odeiv::Step::RKF45, dim)
+c = GSL::Odeiv::Control.y_new(1e-6, 0.0)
+evolve = GSL::Odeiv::Evolve.alloc(dim)
+sys = GSL::Odeiv::System.alloc(func, dim)
+mu = 10.0
+sys.set_params(mu)
+t = 0.0; tend = 100.0
+h = 1e-6
+y = GSL::Vector[1.0, 0.0]
+GSL::ieee_env_setup()
+
+N = 1500
+tt = GSL::Vector[N]
+yt = GSL::Vector[N]
+i = 0
+while t < tend and i < N
+  t, h, status = evolve.apply(c, step, sys, t, tend, h, y)
+  tt[i] = t
+  yt[i] = y[0]
+  break if status != GSL::SUCCESS
+  i += 1
+end
+yt.subvector(i).graph(tt.subvector(i), "-T X -C -g 3 -x 0 #{tt.max} -L '#{step.name}' -S 4")
+
+

data/examples/odeiv/odeiv2.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+dim = 2
+
+func = Proc.new { |t, y, dydt, mu|
+  dydt[0] = y[1]
+  dydt[1] = -y[0] - mu*y[1]*(y[0]*y[0] - 1.0)
+}
+
+jac = Proc.new { |t, y, dfdy, dfdt, mu|
+  dfdy[0,0] = 0.0
+  dfdy[0,1] = 1.0
+  dfdy[1,0] = -2*mu*y[0]*y[1] - 1.0
+  dfdy[1,1] = -mu*(y[0]*y[0] - 1.0)
+  dfdt[0] = 0.0
+  dfdt[1] = 0.0
+}
+
+#solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RK8PD, [1e-6, 0.0, 1, 0], func, jac, dim)
+#solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RK8PD, [1e-6, 0.0, 1, 0], func, nil, dim)
+#solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RK8PD, [1e-6, 0.0], func, nil, dim)
+#solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RKF45, [1e-6, 0.0], func, jac, dim)
+#solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RKF45, [1e-6, 0.0], func, nil, dim)
+solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::BSIMP, [1e-6, 0.0], func, jac, dim)
+solver.set_params(10.0)
+
+t = 0.0; tend = 100.0
+h = 1e-6
+y = GSL::Vector.alloc([1.0, 0.0])
+
+GSL::ieee_env_setup()
+N = 1500
+tt = GSL::Vector[N]
+yt = GSL::Vector[N]
+i = 0
+while t < tend and i < N
+  t, h, status = solver.apply(t, tend, h, y)
+  break if status != GSL::SUCCESS
+  tt[i] = t
+  yt[i] = y[0]
+  i += 1
+end
+
+GSL::graph(tt.subvector(i), yt.subvector(i),  "-T X -C -g 3 -x 0 #{tt.max} -L '#{solver.step.name}' -S 4")