rb-gsl 1.15.3.1

data/examples/multiroot/demo.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+params = [1.0, 10.0]
+func = GSL::MultiRoot::Function.alloc(2, params) { |x, params, f|
+  a = params[0]
+  b = params[1]
+  x0 = x[0]
+  x1 = x[1]
+  f[0] = a*(1 - x0)
+  f[1] = b*(x1 - x0*x0)
+}
+
+fsolver = GSL::MultiRoot::FSolver.alloc("hybrids", 2)
+#fsolver = GSL::MultiRoot::FSolver.alloc("hybrid", 2)
+#fsolver = GSL::MultiRoot::FSolver.alloc("dallocton", 2)
+#fsolver = GSL::MultiRoot::FSolver.alloc("broyden", 2)
+
+x = GSL::Vector.alloc(-10.0, -5.0)
+fsolver.set(func, x)
+#p fsolver.name
+#p fsolver.x
+
+iter = 0
+IO.popen("graph -T X -C -g 3 -X x -Y y -S 4", "w") do |io|
+  begin
+    iter += 1
+    status = fsolver.iterate
+    root = fsolver.root
+    f = fsolver.f
+    printf("iter = %3u x = % .3f % .3f f(x) = % .3e % .3e\n",
+           iter, root[0], root[1], f[0], f[1])
+    io.printf("%e %e\n", root[0], root[1])
+    status = fsolver.test_residual(1e-7)
+  end while status == GSL::CONTINUE and iter < 1000
+end

data/examples/multiroot/fdfsolver.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+n = 2
+
+procf = Proc.new { |x, params, f|
+  a = params[0]
+  b = params[1]
+  x0 = x[0]
+  x1 = x[1]
+  f[0] = a*(1 - x0)
+  f[1] = b*(x1 - x0*x0)
+}
+
+procdf = Proc.new { |x, params, jac|
+  a = params[0]
+  b = params[1]
+  jac[0,0] = -a
+  jac[0,1] = 0
+  jac[1,0] = -2*b*x[0]
+  jac[1,1] = b
+}
+
+params = [1.0, 10.0]
+f = GSL::MultiRoot::Function_fdf.alloc(procf, procdf, n, params)
+
+fdfsolver = GSL::MultiRoot::FdfSolver.alloc("gnewton", n)
+#fdfsolver = GSL::MultiRoot::FdfSolver.alloc("newton", n)
+#fdfsolver = GSL::MultiRoot::FdfSolver.alloc("hybridj", n)
+#fdfsolver = GSL::MultiRoot::FdfSolver.alloc("hybridsj", n)
+p fdfsolver.name
+
+#x = GSL::Vector.alloc(-10.0, -5.0)
+x = [-10.0, -5.0]
+
+#p fdfsolver.x
+
+fdfsolver.set(f, x)
+
+iter = 0
+begin
+  iter += 1
+  status = fdfsolver.iterate
+  root = fdfsolver.root
+  f = fdfsolver.f
+  printf("iter = %3u x = % .3f % .3f f(x) = % .3e % .3e\n",
+          iter, root[0], root[1], f[0], f[1])
+  status = fdfsolver.test_residual(1e-7)
+end while status == GSL::CONTINUE and iter < 1000
+

data/examples/multiroot/fsolver.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+params = [1.0, 10.0]
+func = GSL::MultiRoot::Function.alloc(2, params) { |x, params, f|
+  a = params[0]
+  b = params[1]
+  x0 = x[0]
+  x1 = x[1]
+  f[0] = a*(1 - x0)
+  f[1] = b*(x1 - x0*x0)
+}
+
+#fsolver = GSL::MultiRoot::FSolver.alloc("hybrids", 2)
+#fsolver = GSL::MultiRoot::FSolver.alloc("hybrid", 2)
+#fsolver = GSL::MultiRoot::FSolver.alloc("dallocton", 2)
+fsolver = GSL::MultiRoot::FSolver.alloc("broyden", 2)
+
+x = GSL::Vector.alloc(-10.0, -5.0)
+fsolver.set(func, x)
+#p fsolver.name
+#p fsolver.x
+
+iter = 0
+begin
+  iter += 1
+  status = fsolver.iterate
+  root = fsolver.root
+  f = fsolver.f
+  printf("iter = %3u x = % .3f % .3f f(x) = % .3e % .3e\n",
+          iter, root[0], root[1], f[0], f[1])
+  status = fsolver.test_residual(1e-7)
+end while status == GSL::CONTINUE and iter < 1000

data/examples/multiroot/fsolver2.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+require("gsl")
+include Math
+
+# Expected: x0 ~ 0.57983, x1 ~ 2.54621
+#   (by Octave)
+func = GSL::MultiRoot::Function.alloc(2) { |x, f|
+  x0 = x[0]
+  x1 = x[1]
+  f[0] = -2.0*x0*x0 + 3.0*x0*x1 + 4.0*sin(x1) - 6.0
+  f[1] = 3.0*x0*x0 - 2.0*x0*x1*x1 + 3.0*cos(x0) + 4.0
+}
+
+#fsolver = GSL::MultiRoot::FSolver.alloc("dallocton", 2)
+fsolver = GSL::MultiRoot::FSolver.alloc("broyden", 2)
+p fsolver.name
+
+x = GSL::Vector.alloc([1.0, 2.0])
+fsolver.set(func, x)
+
+iter = 0
+begin
+  iter += 1
+  status = fsolver.iterate
+  root = fsolver.root
+  f = fsolver.f
+  status = fsolver.test_residual(1e-6)
+end while status == GSL::CONTINUE and iter < 1000
+
+x0 = fsolver.root[0]
+x1 = fsolver.root[1]
+printf("%f %f\n", x0, x1)

data/examples/multiroot/fsolver3.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require("gsl")
+include Math
+
+# Expected: x0 ~ 0.57983, x1 ~ 2.54621
+func = GSL::MultiRoot::Function.alloc(2) { |x, f|
+  x0 = x[0]
+  x1 = x[1]
+  f[0] = -2.0*x0*x0 + 3.0*x0*x1 + 4.0*sin(x1) - 6.0
+  f[1] = 3.0*x0*x0 - 2.0*x0*x1*x1 + 3.0*cos(x0) + 4.0
+}
+                            
+p func.solve([1.0, 2.0].to_gv, 1000, 1e-7, "hybrids")
+p func.solve([1.0, 2.0].to_gv, 1000, "broyden")
+p func.solve([1.0, 2.0], "hybrid")
+p func.solve([1.0, 2.0], 2000, "hybrid")
+p func.solve([1.0, 2.0])
+
+#fsolver = GSL::MultiRoot::FSolver.alloc("dallocton", 2)
+fsolver = GSL::MultiRoot::FSolver.alloc("broyden", 2)
+
+x = GSL::Vector.alloc([1.0, 2.0])
+fsolver.set(func, x)
+
+p ans = fsolver.solve()
+#ans = MultiRoot::FSolver.solve(fsolver)

data/examples/narray/histogram.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+N = 10000
+r = GSL::Rng.alloc
+na = r.gaussian(1.0, N).to_na    # Generate N random numbers
+p na.class
+p na.rank
+p na.size
+p na.min
+p na.max
+h = GSL::Histogram.alloc(50, [-4, 4])
+h.fill(na)
+h.graph("-T X -C -g 3")

data/examples/narray/mandel.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+require("gsl")
+require("nimage")
+
+def mandel(w, h)
+  zoom = 3.5
+  z = (GSL::Matrix::Complex[w, 1].indgen!/w - 0.65)*zoom + (GSL::Matrix::Complex[1, h].indgen!/h - 0.5)*zoom*GSL::Complex[0, 1]
+  c = z.clone
+  a = GSL::Vector::Int[w, h]
+  idx = GSL::Vector::Int[h, w].indgen!
+
+  for i in 1..30
+    z = z*z + c
+    idx_t,idx_f = (z.abs>2).where2
+    a[idx[idx_t]] = i
+    break if idx_f.size==0
+    idx = idx[idx_f]
+    z = z[idx_f]
+    c = c[idx_f]
+  end
+  a
+end
+
+NImage.show mandel(400,400).to_na_ref
+
+print "Hit return key..."
+STDIN.getc

data/examples/narray/narray.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+puts("\nGSL::Vector")
+v = GSL::Vector.alloc(1..9)
+p v
+
+puts("\nGSL::Vector ---> NArray")
+vna = v.to_na
+p vna
+
+puts("\nNArray ---> GSL::Vector")
+v2 = GSL::Vector.to_gv(vna)
+p v2
+
+puts("\nGSL::Matrix")
+m = GSL::Matrix.alloc(1..9, 3, 3)
+p m
+
+puts("\nGSL::Matrix ---> NArray")
+mna = m.to_na
+p mna
+
+puts("\nNArray ---> GSL::Matrix")
+m2 = GSL::Matrix.to_gm(mna)
+p m2
+
+

data/examples/narray/narray2.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+na = NArray[1.0, 2, 3, 4, 5, 6, 7 ,8 ,9]
+p na
+v = GSL::Vector.alloc(na)
+p v
+
+v[3] = 99.9
+p v
+p na
+
+na2 = NArray[12.3, 45.6, 78.9, 1.23, 4.56, 7.89]
+p na2
+vref = na2.to_gv_view
+p vref
+vref[1] = 0.00
+p na2
+
+m = NMatrix[[1.0, 2],[3, 4]]
+p m
+
+gm = GSL::Matrix.alloc(m)
+p gm
+
+gm.set(1, 1, 99.9)
+p gm
+p m
+
+gm2 = m.to_gm_view
+
+gm2.set(1, 1, 99.9)
+p gm2
+p m
+
+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]]
+mref = GSL::Matrix.to_gm_view(m)
+mref[1,1] = 123
+p m
+
+mm = GSL::Matrix.to_gm(m)
+mm[1,1] = 456
+p m

data/examples/narray/sf.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+na = NArray[0.1, 0.2, 0.3, 0.4]
+p GSL::Sf::legendre_Pl(2, na)
+
+v = GSL::Vector[0.1, 0.2, 0.3, 0.4]
+p GSL::Sf::legendre_Pl(2, v)
+
+na = NArray[[1.0, 2, 3, 4], [2, 3, 4, 5]]
+p GSL::Sf::sin(na)
+
+m = GSL::Matrix[[1.0, 2, 3, 4], [2, 3, 4, 5]]
+p GSL::Sf::sin(m)
+
+n = 50
+x = GSL::Vector.linspace(0.01, 1, n).to_na
+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)
+p y1.class
+p y2.class
+p y3.class
+p y4.class
+GSL::Vector.graph([x, y1], [x.to_gv, y2], [x, y3.to_gv], [x, y4], "-T X -C -g 3 -y 0 1.1 -X x -L 'Incomplete beta functions'")

data/examples/ntuple/create.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+v = GSL::Vector.alloc(3)
+n = GSL::Ntuple.alloc("test.dat", v)
+
+GSL::Rng.env_setup()
+r = GSL::Rng.alloc
+for i in 0...10000 do
+  for j in 0...3 do
+    v[j] = r.gaussian()
+  end
+  n.write
+end
+
+puts("Data file test.dat is created.")
+puts("Try project.rb.")

data/examples/ntuple/project.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+sel_func = GSL::Ntuple::SelectFn.alloc { |data, params|
+  x = data[0]; y = data[1]; z = data[2]
+  scale = params
+
+  e2 = x*x + y*y + z*z
+  e2 > scale
+}
+
+lower = 1.5
+sel_func.set_params(lower)
+
+val_func = GSL::Ntuple::ValueFn.alloc { |data|
+  x = data[0]; y = data[1]; z = data[2]
+  x*x + y*y + z*z
+}
+
+v = GSL::Vector.alloc(3)
+n = GSL::Ntuple.open("test.dat", v)
+
+h = GSL::Histogram.alloc(100)
+h.set_ranges_uniform(0, 10.0)
+
+#Ntuple.project(h, n, val_func, sel_func)
+n.project(h, val_func, sel_func)
+
+h.graph("-C -X 'E2' -Y 'n' -L 'GSL::Ntuple, Select E2 > 1.5'")
+File.delete("test.dat")
+

data/examples/odeiv/binarysystem.gp

@@ -0,0 +1,23 @@
+set title 'Orbital decay of the binary system J0730-3039'
+set xlabel 'Time since birth [Myr]'
+set ylabel 'Orbital Period [Hr]'
+set y2label 'Eccentricity'
+
+set grid
+set yrange [1e-2:10]
+set xrange [90:200]
+set y2range [1e-4:1e-1]
+#set xrange [90:2500]
+#set y2range [1e-4:2e-1]
+
+set ytics nomirror
+set y2tics
+set logscale y
+set logscale y2
+
+set pointsize 1
+set label 1 'Present' at first 96, 0.04
+set label 2 'Plunge!' at first 150, 0.04
+set arrow from 100,0.03 to 100,0.013 lw 2 lt 3
+set arrow from 160, 0.035 to 182, 0.011 lw 2 lt 4
+plot 'binarysystem.dat' u 1:2 title 'Orbital period' w lp lw 1, '' u 1:3 axes x1y2 title 'Eccentricity' w lp lw 1

data/examples/odeiv/binarysystem.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+#      19/Apr/2004         by Yoshiki Tsunesada
+#
+#   This is an example to calculate the orbital evolution of
+# a double neutron star (binary) system. General relativity predicts 
+# that the binary orbital decays by radiating gravitational waves, 
+# and the two stars will coalesce in time scale of 100-1000 Mega-years. 
+#   The values used here are of the binary system J0730-3039 discovered 
+# in 2003 (Burgay et al., Nature 2003). The result shows that the two 
+# neutron stars will merge after about 85 Mega-years. From the age of 
+# the system 100 Mega-year, the lifetime of the system is estimated 
+# about 185 Mega-years.
+#
+# References:
+#   1. Burgay et al., Nature 426, 531 (2003)
+#   2. Shapiro & Teukolsky, "Black holes, white dwarfs and neutron stars"
+#        John Wiley and Sans (1983)
+#
+ 
+require("gsl")
+include Math
+
+class BinarySystem
+  def initialize(m1, m2)
+    @m1 = m1
+    @m2 = m2
+  end
+  attr_reader :m1
+  attr_reader :m2
+end
+
+GMsolarC3 = 4.925490947e-6
+MegaYear = 3600*24*365*1e6
+
+# Time evolution of the binary orbital period and the eccentricity
+# due to gravitational radiation. 
+# The calculation is based on general relativity (See e.g. Ref.2).
+#     y[0]: orbital period (pb)
+#     y[1]: eccentricity (e)
+#  dydt[0]: time derivative of pb
+#  dydt[1]: time derivative of e
+
+deriv = Proc.new { |t, y, dydt, binary|
+  pb = y[0]            # orbital period
+  e = y[1]             # eccentricity
+  m1 = binary.m1       # neutron star masses
+  m2 = binary.m2
+  totalM = m1 + m2     # total mass                           
+  mu = m1*m2/totalM    # reduced mass
+  mm = mu*GSL::pow(totalM, 2.0/3.0)
+  f_e = GSL::pow(1.0 - e*e, -3.5)*(1.0 + (73.0/24.0 + 37.0/96.0*e*e)*e*e);
+  h_e = (1.0 + 121.0/304.0*e*e)*GSL::pow(1.0 - e*e, -2.5)
+  tmp = GSL::pow(GMsolarC3*2.0*PI/pb, 5.0/3.0)
+  dydt[0] = -192.0*PI/5.0*f_e*tmp*mm              # dP/dt
+  dydt[1] = -304.0/15.0*e*h_e*tmp*(2.0*PI/pb)     # de/dt
+}
+
+# Neutron star masses in solar-mass unit.
+# The values are of the binary system J0730-3039 discoverd in 2003.
+# See Burgay et al., Nature 426, 531 (2003)
+m1 = 1.34
+m2 = 1.24
+#m1 = 1.25
+#m2 = 2.574 - m1
+binary = BinarySystem.new(m1, m2)
+
+# Initial data: the present values
+pb = 2.45*3600        # orbital period: 2.45 hours at present
+ecc = 0.088           # eccentricity
+#pb = 7.67*3600
+#ecc = 0.181
+y = GSL::Vector[pb, ecc]
+
+# ODE solver using RKF45 algorithm
+solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RKF45, [1e-6, 0.0], deriv, 2)
+solver.set_params(binary)
+
+# the age of the binary system from birth
+age = 100*MegaYear
+#age = 444*MegaYear
+t = 0
+tend = 2500*MegaYear
+
+# initial time step
+h = 1.0*MegaYear
+
+begin
+  file = File.open("binarysystem.dat", "w") 
+  while t < tend 
+    t, h, status = solver.apply(t, tend, h, y)
+    break if status != GSL::SUCCESS
+    break if GSL::isnan?(y[0])
+    file.printf("%e %e %e %e\n", (t+age)/MegaYear, y[0]/3600, y[1], h/MegaYear)
+  end
+ensure
+  file.close
+end
+
+system("gnuplot -persist binarysystem.gp")
+File.delete("binarysystem.dat")
+
+__END__
+
+