rb-gsl 1.15.3.1

data/examples/odeiv/oscillator.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# An oscillator
+#   m: mass
+#   k: spring constant
+#   b: resist
+#   f: external force
+
+require("gsl") 
+
+dim = 2
+
+# x[0]: displacement, x[1]: velocity
+func = Proc.new { |t, x, dxdt, params|
+  m = params[0]; b = params[1]; f = params[2]; k = params[3]
+  dxdt[0] = x[1]
+  dxdt[1] = (f - b*x[1] - k*x[0])/m
+}
+
+gos = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RKF45, [1e-6, 0.0], func, dim)
+
+m = 1.0
+b = 1.0
+f = 1.0
+k = 10.0
+
+gos.set_params(m, b, f, k)
+
+t = 0.0; tend = 10.0
+h = 1e-6
+x = GSL::Vector.alloc([0.0, 0.0])
+
+GSL::ieee_env_setup()
+
+IO.popen("graph -T X -C -g 3 -S 4 -X Time -Y Amp", "w") do |io|
+  while t < tend
+    t, h, status = gos.apply(t, tend, h, x)
+    break if status != GSL::SUCCESS
+#    printf("%.5e %.5e %.5e %.5e\n", t, x[0], x[1], h)
+    io.printf("%.5e %.5e\n", t, x[0])
+  end
+end
+

data/examples/odeiv/sedov.rb

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+# Self-similar solution of the Sedev-Taylor equation,
+# which describes spherically expanding gas
+# triggered by a supernova explosion.
+
+require("gsl")
+include Math
+
+# Sedov-Taylor equation
+#     logx: (log of) the radial coordinate in the gas shpere, x = r/R.
+#           logx = 0 at the surface, and negative within the shell
+#        y: GSL::GSL::Vector::View::ReadOnly
+#           y[0]: gas velocity at the radius
+#           y[1]: density
+#           y[2]: pressure
+#  dydlogx: GSL::GSL::Vector::View, derivatives
+#       sh: specific heat of the gas (5/3)
+Sedov = Proc.new { |logx, y, dydlogx, sh|
+  a = -5.0*(6.0*y[2] - 15.0*y[2]*y[0]*sh + 2.0*y[0]*y[1] - 7.0*y[0]*y[0]*y[1] + 5.0*GSL::pow_3(y[0])*y[1])
+  b = -25.0*y[2]*sh + 4.0*y[1] - 20.0*y[0]*y[1] + 25.0*y[0]*y[0]*y[1]
+  dydlogx[0] = a/b             
+
+  bb = -5.0*(6.0*y[2] - 15.0*y[2]*y[0]*sh + 2.0*y[0]*y[1] - 7.0*y[0]*y[0]*y[1])
+
+  a = -5.0*(-30.0*y[2]*y[1] + 2.0*y[0]*y[1]*y[1] - 25.0*GSL::pow_2(y[0]*y[1]) + 50.0*GSL::pow_3(y[0])*GSL::pow_2(y[1]))
+  bb = (-2.0 + 5.0*y[0])*(-25.0*y[2]*sh + 4.0*y[1] - 20.0*y[0]*y[1] + 25.0*y[0]*y[0]*y[1])
+  dydlogx[1] = a/bb       
+
+  a = -5.0*y[2]*(-10.0*y[2]*sh + 4.0*y[1] - 14.0*y[0]*y[1] + 10.0*y[0]*y[0]*y[1] - y[0]*sh*y[1] + 10.0*y[0]*y[0]*sh*y[1])
+  dydlogx[2] = a/b             
+}
+
+DIM = 3
+sh = 5.0/3.0
+solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RKF45, [1e-5, 1e-5], Sedov, nil, DIM)
+solver.set_params(sh)
+
+def boundary_condition(sh)
+  delta = 2.0/5.0
+  xx = 1
+  y = GSL::Vector[DIM]
+  y[0] = 2.0/(sh + 1.0)*delta
+  y[1] = (sh + 1.0)/(sh - 1.0)
+  y[2] = 2.0/(sh + 1.0)*delta*delta
+  y00 = xx*y[0]
+  y10 = y[1]
+  y20 = xx*xx*y[2]
+  c = adiabatic_integ(xx, y, sh);
+  return y, y00, y10, y20, c
+end
+
+def adiabatic_integ(xx, y, sh)
+  GSL::pow(y[1], 1.0 - sh)*y[2]*(y[0] - 2.0/5.0)*GSL::pow_5(xx)
+end
+
+# y: GSL::Vector (velocity, density, pressure)
+# y00, y10, y20: initial values
+# c: adiabatic integral (this must be constant throughout the computation)
+y, y00, y10, y20, c = boundary_condition(sh)
+
+# x: the radial coordinates in the shell, x = r/R.
+#     x = 1 at the surface (r = R), and zero at the center (r = 0)
+x = 1
+logx = log(x)
+logxend = log(1e-5)
+h = -0.000001
+
+N = 150
+R = GSL::Vector[N]
+V = GSL::Vector[N]
+RHO = GSL::Vector[N]
+PRESS = GSL::Vector[N]
+
+# The values are normalized to [0, 1]
+R[0] = x
+V[0] = x*y[0]/y00
+RHO[0] = y[1]/y10
+PRESS[0] = x*x*y[2]/y20
+
+GSL::ieee_env_setup()
+
+n = 1
+while logx > logxend
+  logx, h, status = solver.apply(logx, logxend, h, y)
+  break if status != GSL::SUCCESS
+  break if y[0] < 0.0
+  x = exp(logx)
+  c = adiabatic_integ(x, y, sh);
+  R[n] = x
+  V[n] = x*y[0]/y00
+  RHO[n] = y[1]/y10
+  PRESS[n] = x*x*y[2]/y20
+  n += 1
+end
+
+GSL::graph(R.subvector(n), V.subvector(n), RHO.subvector(n), PRESS.subvector(n),
+      "-T X -C -g 3 -X 'x = r/R' -S 4 -L 'red: v, green: rho, blue: p'")

data/examples/odeiv/whitedwarf.gp

@@ -0,0 +1,40 @@
+#set terminal postscript eps enhanced color
+#set output 'whitedwarf.eps'
+set multiplot
+set size 0.5, 0.5
+
+set grid
+set origin 0, 0.5
+#set xlabel 'r/R'
+#set ylabel '{/Symbol r}/{/Symbol r}_c'
+set xlabel 'Radius (normalized)'
+set ylabel 'Density (normalized)'
+set xrange [0:1]
+plot 'polytrope.dat' u ($1/6.8969):4 title 'Density Dist' w l lt 1 lw 5
+
+set origin 0.5, 0.5
+set logscale x
+set xrange [1e6:1e11]
+#set xlabel '{/Symbol r}_c [g/cm^3]'
+set xlabel 'Central Density [g/cm^3]'
+set ylabel 'Radius [km]'
+#plot 'whitedwarf.dat' u 1:3 title '{/Symbol r}_c - Radius' w l lw 5
+plot 'whitedwarf.dat' u 1:3 title 'Central Density - Radius' w l lt 2 lw 5
+
+set origin 0, 0
+set logscale x
+set xrange [1e6:1e11]
+set yrange [0.5:1.6]
+#set xlabel '{/Symbol r}_c [g/cm^3]'
+set xlabel 'Central Density [g/cm^3]'
+set ylabel 'WD Mass [Msolar]'
+plot 'whitedwarf.dat' u 1:4 title 'Central Density - Mass' w l lt 3 lw 5
+
+set origin 0.5, 0
+unset logscale x
+set xrange [0.5:1.5]
+set yrange [100:25000]
+set xlabel 'Mass [Msolar]'
+set ylabel 'Radius [km]'
+plot 'whitedwarf.dat' u 4:3 title 'Mass - Radius' w l lt 4 lw 5
+

data/examples/odeiv/whitedwarf.rb

@@ -0,0 +1,158 @@
+#!/usr/bin/env ruby
+# This example solves Lane-Emden equation to calculate white dwarf
+# structure, using Chandrasekhar's model, as a polytrope gas sphere
+# of self-gravitating body supported by eletron degeneration pressure.
+
+require("gsl")
+include Math
+include GSL::CONST::CGSM
+include GSL::Odeiv
+
+# Degenerated electron/neutron gas
+# Reference: "Black holes, white dwarfs, and neutron stars"
+#            S.L. Shapiro & S.A. Teukolsky, Willey, 1983
+module Degenerate
+  hbar = PLANCKS_CONSTANT_HBAR    # Planck's constant
+  me = MASS_ELECTRON              # Electron mass
+  mn = MASS_NEUTRON               # Neutron mass
+  mu = UNIFIED_ATOMIC_MASS        
+  c = SPEED_OF_LIGHT            
+  ELambda = hbar/me/c             # Compton length of electron
+  NLambda = hbar/mn/c
+  MeC2 = me*c*c                   # Electron rest mass energy
+  MnC2 = mn*c*c
+  Factor_xe = GSL::pow(3.0*PI*PI/mu, 1.0/3.0)*ELambda
+  Factor_xn = GSL::pow(3.0*PI*PI/mu, 1.0/3.0)*NLambda
+
+# See Shapiro&Teukolsky Chapter 2
+  def phi(x)
+    tmp = sqrt(1.0 + x*x)
+    (x*tmp*(2.0*x*x/3.0 - 1.0) + log(x + tmp))/8/PI/PI
+  end
+  
+  def chi(x)
+    tmp = sqrt(1.0 + x*x)
+    (x*tmp*(1.0 + 2*x*x) - log(x + tmp))/8/PI/PI
+  end
+  
+  def xe_rho_mue(rho, mue)
+    Factor_xe*GSL::pow(rho/mue, 1.0/3.0)
+  end
+ 
+  def xn_rho(rho)
+    Factor_xn*GSL::pow(rho, 1.0/3.0)
+  end
+ 
+end
+
+# Polytrope gas sphere
+module Polytrope 
+
+# Lane-Emden equation
+#   n: polytrope index
+  EmdenEq = Proc.new { |x, y, dydx, n|
+    dydx[0] = y[1]
+    dydx[1] = -GSL::pow(y[0], n) - 2.0/x*y[1]
+  }
+
+  def emden_xi(n)
+    dim = 2
+    y = GSL::Vector[1.0, 0.0]
+    dydx = GSL::Vector.alloc(dim)
+    
+    solver = Solver.alloc(Step::RKF45, [1e-6, 0], EmdenEq, dim)
+    solver.set_params(n)
+    solver.reset
+
+    vx = GSL::Vector.alloc(10000)
+    vy = GSL::Vector.alloc(10000)
+    vdy = GSL::Vector.alloc(10000)
+
+    x = 0.0001
+    xend = 10.0
+    h = 1e-6
+    
+    file = File.open("polytrope.dat", "w")
+    i = 0
+    while x < xend
+      x, h, status = solver.apply(x, xend, h, y)
+      break if GSL::isnan?(y[0])
+      break if GSL::isnan?(y[1])
+      vx[i] = x
+      vy[i] = y[0]
+      vdy[i] = y[1]
+      file.printf("%e %e %e %e\n", x, y[0], y[1], GSL::pow_3(y[0]))
+      i += 1
+      break if status != GSL::SUCCESS
+      break if y[0] <= -0.1
+    end
+    file.close
+#    p vx.size
+#    p i
+    vx2 = vx.subvector(0, i)
+    vy2 = vy.subvector(0, i)
+    vdy2 = vdy.subvector(0, i)
+    spline = GSL::Spline.alloc(GSL::Interp::AKIMA, i)
+    spline.init(vy2.reverse, vx2.reverse)
+    
+# Find star surface:
+# Star sufrace is defined as the zero point of density structure function
+    x1 = spline.eval(0.0)      
+    spline.init(vx2, vdy2)
+    yx2 = spline.eval(x1).abs
+    return [x1, yx2*x1*x1]
+
+  end
+end
+
+# Chandrasekhar white dwarf model:
+#   * Polytrope gas sphere
+#   * Support its self gravity by electron degeneration pressure
+class WhiteDwarf
+  include Degenerate
+  include Polytrope
+
+  G = GRAVITATIONAL_CONSTANT
+  @@x1 = nil
+  @@x12 = nil
+
+  def initialize(n, rhoc, mue)
+    @n = n
+    @gam = 1.0 + 1.0/n
+    @rhoc = rhoc
+    @mue = mue
+    x = xe_rho_mue(@rhoc, mue)
+    phix = phi(x)
+    @K = MeC2*phix/GSL::pow_3(ELambda)/GSL::pow(@rhoc, @gam)
+    @a = sqrt((@n + 1)*@K*GSL::pow(@rhoc, 1.0/@n - 1.0)/4/PI/G)
+    if !@@x1
+      @@x1, @@x12 = emden_xi(@n)
+    end
+    @Pc = MeC2*phix/GSL::pow_3(ELambda)*phix   # Electron Fermi pressure
+    @radius = @a*@@x1                     # White dwarf radius
+    @mass = 4.0*PI*GSL::pow_3(@a)*@rhoc*@@x12  # White dwarf mass
+  end
+
+  attr_accessor :radius
+  attr_accessor :mass
+  attr_accessor :rhoc    # Central density
+  attr_accessor :Pc      # Central pressure
+  attr_accessor :gam     # Adiabatic index
+  attr_accessor :n       # Polytrope index
+  attr_accessor :mue     # Mean eletron number per barion
+  attr_accessor :K       # Normalization constant
+  attr_accessor :a
+end
+
+file = File.open("whitedwarf.dat", "w")
+rho = 1e6     # central density
+while rho < 1e11
+  wd = WhiteDwarf.new(3, rho, 2)
+  file.printf("%e %e %e %e\n", rho, wd.Pc, wd.radius/1000/100, wd.mass/SOLAR_MASS)
+  rho *= 1.2
+end
+file.close
+
+system("gnuplot -persist whitedwarf.gp")
+File.delete("polytrope.dat")
+File.delete("whitedwarf.dat")

data/examples/ool/conmin.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+require("gsl")
+require("ool/conmin.rb")
+
+def iteration_echo(m)
+  f = m.f
+  x = m.x
+  printf( "f( " );
+  for i in 0...3 do
+    printf( "%+6.3e, ", x[i])
+  end
+  printf( "... ) = %+6.3e\n", f )
+
+end
+
+NN = 100
+
+fun = Proc.new { |x, params|
+  n = x.size
+  f = 0
+  for i in 0...n do
+    ai = params[i]
+    xi = x[i]
+    f += (xi - ai)*(xi - ai)
+  end
+  f
+}
+
+fun_df = Proc.new { |x, params, g|
+  n = x.size
+  for i in 0...n do
+    ai = params[i]
+    xi = x[i]
+    g[i] = 2.0*(xi - ai)
+  end
+}
+
+fun_Hv = Proc.new { |x, params, v, hv|
+  n = x.size
+  for i in 0...n do
+    hv[i] = 2.0*v[i]
+  end
+}
+
+a = GSL::Vector.alloc(NN)
+for i in 0...NN do
+  a[i] = (i.to_f + 1.0)/10.0
+end
+f = OOL::Conmin::Function.alloc()
+f.set(NN, fun, fun_df, nil, fun_Hv, a)
+
+L = GSL::Vector.alloc(NN)
+U = GSL::Vector.alloc(NN)
+L.set_all(-3.0)
+U.set_all(3.0)
+c = OOL::Conmin::Constraint.alloc()
+c.set(NN, L, U)
+
+m = OOL::Conmin::Minimizer.alloc(OOL::Conmin::Minimizer::Spg, NN)
+#m = OOL::Conmin::Minimizer.alloc(OOL::Conmin::Minimizer::Pgrad, NN)
+#m = OOL::Conmin::Minimizer.alloc("pgrad", NN)
+#m = OOL::Conmin::Minimizer.alloc("spg", NN)
+
+#params = OOL::Conmin::Minimizer::Spg.parameters_default
+params = m.parameters_default
+p params.class
+p params
+
+x = GSL::Vector.alloc(NN)
+x.set_all(1.0)
+m.set(f, c, x, params)
+
+ii = 0
+NMAX = 10000
+status = OOL::CONTINUE;
+
+printf( "%4d : ", ii )
+iteration_echo ( m )
+while ii < NMAX && status == OOL::CONTINUE
+  ii+=1
+  m.iterate
+  status = m.is_optimal
+
+  printf( "%4d : ", ii )
+  iteration_echo( m )
+end
+
+printf("%s method\n", m.name)
+if status == OOL::SUCCESS
+  printf("\nConvergence in %i iterations\n\n", ii);
+else
+  printf("Stopped with %i iterations\n", ii);
+end
+printf("variables................: %6d\n", NN)
+printf("function evaluations.....: %6d\n", m.fcount)
+printf("gradient evaluations.....: %6d\n", m.gcount)
+printf("function value...........: %.6e\n", m.minimum)
+printf("projected gradient norm..: %.6e\n", m.size)
+
+

data/examples/ool/gencan.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+require("gsl")
+require("ool/conmin.rb")
+
+def iteration_echo(m)
+  f = m.f
+  x = m.x
+  printf( "f( " );
+  for i in 0...3 do
+    printf( "%+6.3e, ", x[i])
+  end
+  printf( "... ) = %+6.3e, ||g||=%6.3e\n", f, m.size)
+
+end
+
+NN = 100
+
+fun = Proc.new { |x, params|
+  n = x.size
+  f = 0
+  for i in 0...n do
+    xi = x[i] - (i.to_f+1.0)/10.0
+    f += (i + 1.0)*xi*xi
+  end
+  f
+}
+
+fun_df = Proc.new { |x, params, g|
+  n = x.size
+  for i in 0...n do
+    xi = x[i] - (i.to_f+1.0)/10.0
+    g[i] = 2.0*(i+1.0)*xi
+  end
+}
+
+fun_Hv = Proc.new { |x, params, v, hv|
+  n = x.size
+  for i in 0...n do
+    hv[i] = 2.0*(i+1.0)*v[i]
+  end
+}
+
+a = GSL::Vector.alloc(NN)
+for i in 0...NN do
+  a[i] = (i.to_f + 1.0)/10.0
+end
+f = OOL::Conmin::Function.alloc()
+f.set(NN, fun, fun_df, nil, fun_Hv, a)
+
+L = GSL::Vector.alloc(NN)
+U = GSL::Vector.alloc(NN)
+L.set_all(-3.0)
+U.set_all(3.0)
+c = OOL::Conmin::Constraint.alloc()
+c.set(NN, L, U)
+
+#m = OOL::Conmin::Minimizer.alloc(OOL::Conmin::Minimizer::Spg, NN)
+#m = OOL::Conmin::Minimizer.alloc(OOL::Conmin::Minimizer::Pgrad, NN)
+m = OOL::Conmin::Minimizer.alloc(OOL::Conmin::Minimizer::Gencan, NN)
+#m = OOL::Conmin::Minimizer.alloc("pgrad", NN)
+#m = OOL::Conmin::Minimizer.alloc("spg", NN)
+
+#params = OOL::Conmin::Minimizer::Spg.parameters_default
+params = m.parameters_default
+
+x = GSL::Vector.alloc(NN)
+for i in 0...NN do
+  x[i] = 1.0 + i
+end
+m.set(f, c, x, params)
+
+ii = 0
+NMAX = 1000
+status = OOL::CONTINUE;
+
+printf( "%4d : ", ii )
+iteration_echo ( m )
+while ii < NMAX && status == OOL::CONTINUE
+  ii+=1
+  m.iterate
+  status = m.is_optimal
+
+  printf( "%4d : ", ii )
+  iteration_echo( m )
+end
+
+printf("%s method\n", m.name)
+if status == OOL::SUCCESS
+  printf("\nConvergence in %i iterations\n\n", ii);
+else
+  printf("Stopped with %i iterations\n", ii);
+end
+printf("variables................: %6d\n", NN)
+printf("function evaluations.....: %6d\n", m.fcount)
+printf("gradient evaluations.....: %6d\n", m.gcount)
+printf("function value...........: %.6e\n", m.minimum)
+printf("projected gradient norm..: %.6e\n", m.size)
+
+