rb-gsl 1.15.3.1

data/examples/const/travel.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+include GSL::CONST::MKSA
+puts("In MKSA unit")
+
+c  = SPEED_OF_LIGHT;
+au = ASTRONOMICAL_UNIT;
+minutes = MINUTE;
+
+# distance stored in meters 
+r_earth = 1.00 * au;  
+r_mars  = 1.52 * au;
+
+t_min = (r_mars - r_earth) / c;
+t_max = (r_mars + r_earth) / c;
+
+printf("light travel time from Earth to Mars:\n");
+printf("c = %e [m/s]\n", c)
+printf("AU = %e [m]\n", au)
+printf("minutes = %e [s]\n", minutes)
+printf("minimum = %.1f minutes\n", t_min / minutes);
+printf("maximum = %.1f minutes\n\n", t_max / minutes);
+
+
+include GSL::CONST::CGSM
+puts("In CGSM unit")
+
+c  = SPEED_OF_LIGHT;
+au = ASTRONOMICAL_UNIT;
+minutes = MINUTE;
+
+# distance stored in meters 
+r_earth = 1.00 * au;  
+r_mars  = 1.52 * au;
+
+t_min = (r_mars - r_earth) / c;
+t_max = (r_mars + r_earth) / c;
+
+printf("light travel time from Earth to Mars:\n");
+printf("c = %e [cm/s]\n", c)
+printf("AU = %e [cm]\n", au)
+printf("minutes = %e [s]\n", minutes)
+printf("minimum = %.1f minutes\n", t_min / minutes);
+printf("maximum = %.1f minutes\n", t_max / minutes);

data/examples/deriv/demo.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+f = GSL::Function.alloc { |x| Math::exp(-x) }
+
+puts("f(x) = exp(-x)");
+puts("Derivative: -exp(-x)")
+
+h = 1e-8
+x = GSL::Vector.linspace(0, 5, 50)
+y = f.eval(x)
+dy, derr = f.deriv_central(x, h)
+GSL::graph(x, y, dy, "-T X -C -g 3 -X x -L 'f(x) = exp(-x), and its derivative'")

data/examples/deriv/deriv.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+f = GSL::Function.alloc { |x|
+  GSL::pow(x, 1.5)
+}
+
+printf("f(x) = x^(3/2)\n");
+
+x = 2.0
+h = 1e-8
+result, abserr, status = f.deriv_central(x, h)
+printf("x = 2.0\n");
+printf("f'(x) = %.10f +/- %.10f\n", result, abserr);
+printf("exact = %.10f\n\n", 1.5 * Math::sqrt(2.0));
+
+x = 0.0
+result, abserr, status = GSL::Deriv.forward(f, x, h)
+printf("x = 0.0\n");
+printf("f'(x) = %.10f +/- %.10f\n", result, abserr);
+printf("exact = %.10f\n", 0.0);
+
+f2 = GSL::Function.alloc { |x, a| Math::exp(a*x) }
+
+f2.set_params(2)
+p f2.deriv_central(0)
+
+f2.set_params(3)
+p f2.deriv_central(0)
+
+f2.set_params(123)
+p f2.deriv_central(0, h)
+
+p GSL::Deriv.central(f2, 0)
+p GSL::Deriv.forward(f2, 0)
+p GSL::Deriv.backward(f2, 0)

data/examples/deriv/diff.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+f = GSL::Function.alloc { |x|
+  GSL::pow(x, 1.5)
+}
+
+printf("f(x) = x^(3/2)\n");
+
+x = 2.0
+result, abserr,status = f.diff_central(x)
+printf("x = 2.0\n");
+printf("f'(x) = %.10f +/- %.5f\n", result, abserr);
+printf("exact = %.10f\n\n", 1.5 * Math::sqrt(2.0));
+
+x = 0.0
+result, abserr, status = f.diff_forward(x)
+printf("x = 0.0\n");
+printf("f'(x) = %.10f +/- %.5f\n", result, abserr);
+printf("exact = %.10f\n", 0.0);
+
+f2 = GSL::Function.alloc { |x, a| Math::exp(a*x) }
+
+f2.set_params(2)
+p f2.diff_central(0)
+
+f2.set_params(3)
+p f2.diff_central(0)
+
+f2.set_params(123)
+p f2.diff_central(0)
+
+p GSL::Diff.central(f2, 0)
+p GSL::Diff.forward(f2, 0)
+p GSL::Diff.backward(f2, 0)

data/examples/dht.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+require("gsl")
+include Math
+
+# Function to be expanded
+G = GSL::Function.alloc { |x| exp(-x*x) }
+#G = Function.alloc { |x| sin(-x*x) }
+
+# Sampling points
+XMIN = 0.0
+XMAX = 3.0
+SIZE = 20
+
+x = GSL::Vector.linspace(XMIN, XMAX, SIZE)
+sample = G.eval(x)
+
+# Discrete Hankel transform with the Bessel function J0
+dht = GSL::Dht.alloc(SIZE, 0, XMAX)
+g = dht.apply(sample)
+
+num = dht.num
+den = dht.den
+coef = dht.coef
+
+# Reconstruction
+y = GSL::Vector[SIZE]
+for n in 0...SIZE do
+  val = 0.0
+  for m in 0...SIZE do
+    a = GSL::Sf::bessel_J0(dht.sample(n, m))
+    val += (2.0/XMAX/XMAX)*a/den[m]*g[m]
+#    val += (2.0/XMAX/XMAX)*num[n][m]/den[m]*g[m]
+#    val += coef[n][m]*g[m]
+  end
+  y[n] = val
+end
+
+x0 = GSL::Vector.linspace(XMIN, XMAX, 100)
+y0 = G.eval(x0)
+
+GSL::graph([x0, y0], [x, sample], [x, y], "-T X -C -g 3 -X t -Y 'f(t)' --toggle-rotate-y-label -L 'Red: f(t), Green: sample, Blue: DHT of size #{SIZE}'")
+

data/examples/dirac.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL::Dirac
+
+I = GSL::Complex[0, 1]
+
+p Pauli1
+p Pauli2
+p Pauli3
+
+p (Pauli1*Pauli2 - Pauli2*Pauli1)/I/2
+
+p Dirac.anticommute(Pauli1, Pauli1)
+p Dirac.anticommute(Pauli1, Pauli2)
+
+#p Eye2
+#p Eye4
+
+p Beta
+
+p Alpha1
+p Alpha2
+p Alpha3
+
+p Alpha1*Alpha1
+p Alpha2*Alpha2
+p Alpha3*Alpha3
+
+p GSL::Dirac.anticommute(Alpha1, Alpha1)
+p GSL::Dirac.anticommute(Alpha1, Alpha2)
+
+p GSL::Dirac.anticommute(Gamma0, Gamma0)
+p GSL::Dirac.anticommute(Gamma1, Gamma1)
+p GSL::Dirac.anticommute(Gamma2, Gamma2)
+p GSL::Dirac.anticommute(Gamma3, Gamma3)
+p GSL::Dirac.anticommute(Gamma3, Gamma0)
+
+p IEye4*Gamma0*Gamma1*Gamma2*Gamma3
+
+p Pauli2
+p Pauli2.conjugate
+p Pauli2
+p Pauli3
+p Pauli3.dagger
+
+p Lambda1
+p Lambda2
+p Lambda3
+p Lambda4
+p Lambda5
+p Lambda6
+p Lambda7
+p Lambda8
+
+
+

data/examples/eigen/eigen.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+m = GSL::Matrix[[1.0, 1/2.0, 1/3.0, 1/4.0], [1/2.0, 1/3.0, 1/4.0, 1/5.0],
+           [1/3.0, 1/4.0, 1/5.0, 1/6.0], [1/4.0, 1/5.0, 1/6.0, 1/7.0]]
+
+eigval = m.eigen_symm
+p eigval
+
+eigval, eigvec = m.eigen_symmv
+
+p eigval == GSL::Eigen.symm(m)
+val, vec = GSL::Eigen.symmv(m)
+p vec
+
+i = 0
+vec.each_col do |v|
+  a = (m*v)/v
+  if a != val[i]
+    puts("error")
+  end
+  i += 1
+end
+
+# Diagonalization
+b = eigvec.inv*m*eigvec
+b.clean!(1e-10)
+p b
+d = b.diagonal
+p d == eigval
+
+prod = eigval.prod
+p GSL.equal?(prod, m.det, 1e-10)
+

data/examples/eigen/herm.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+include GSL::Eigen
+
+m = GSL::Matrix::Complex.alloc(2, 2)
+m.set(0, 1, [0, -1])
+m.set(1, 0, [0, 1])
+p m
+
+val, vec = m.eigen_hermv
+p val
+p vec.unpack
+
+m2 = GSL::Matrix.alloc([1, 0, 0], [0, 0, 1], [0, 1, 0])
+val, vec = m2.eigen_symmv
+p val
+p vec.unpack
+
+
+
+

data/examples/eigen/narray.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+m = NMatrix[[1.0, 1/2.0, 1/3.0, 1/4.0], [1/2.0, 1/3.0, 1/4.0, 1/5.0],
+            [1/3.0, 1/4.0, 1/5.0, 1/6.0], [1/4.0, 1/5.0, 1/6.0, 1/7.0]]
+
+p GSL::Eigen.symm(m)
+p GSL::Eigen.symmv(m)
+

data/examples/eigen/nonsymm.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+m = GSL::Matrix[[1, 2], [3, 4]]
+
+w = GSL::Eigen::Nonsymm::Workspace.alloc(2)
+v = GSL::Vector::Complex.alloc(2)
+
+#w.params(0, 1)
+
+#p GSL::Eigen.nonsymm(m)
+#p GSL::Eigen.nonsymm(m, v, w)
+
+p m.eigen_nonsymm
+#p m.eigen_nonsymm(v, w)
+
+#p m.eigen_nonsymm_Z
+#p m
+
+
+=begin
+Octave result:
+
+octave:1> m = [1 2; 3 4]
+m =
+
+  1  2
+  3  4
+
+octave:2> eig(m)
+ans =
+
+  -0.37228
+   5.37228
+
+
+=end

data/examples/eigen/nonsymmv.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+m = GSL::Matrix[[1, 2, 3], [4, 5, 0], [6, 0, 0]]
+evec, eval = m.eigen_nonsymmv
+p evec
+p eval
+
+m = GSL::Matrix.vandermonde([-1, -2, 3, 4])
+w = GSL::Eigen::Nonsymmv.alloc(4)
+eval, evec = GSL::Eigen::nonsymmv(m, w)
+p eval
+p evec
+
+=begin
+This can be compared with the corresponding output from GNU OCTAVE, 
+
+  octave> [v,d] = eig(vander([-1 -2 3 4]));
+octave> diag(d)
+ans =
+
+  -6.4139 + 0.0000i
+   5.5456 + 3.0854i
+   5.5456 - 3.0854i
+   2.3228 + 0.0000i
+
+octave> v
+v =
+
+ Columns 1 through 3:
+
+  -0.09988 + 0.00000i  -0.04350 - 0.00755i  -0.04350 + 0.00755i
+  -0.11125 + 0.00000i   0.06399 - 0.14224i   0.06399 + 0.14224i
+   0.29250 + 0.00000i  -0.51518 + 0.04142i  -0.51518 - 0.04142i
+   0.94451 + 0.00000i  -0.84059 + 0.00000i  -0.84059 - 0.00000i
+
+ Column 4:
+
+  -0.14493 + 0.00000i
+   0.35660 + 0.00000i
+   0.91937 + 0.00000i
+   0.08118 + 0.00000i
+=end

data/examples/eigen/qhoscillator.gp

@@ -0,0 +1,35 @@
+set multiplot
+set size 0.5, 0.5
+set grid
+set key box
+set xrange [-5.5:5.5]
+
+# Hermite Polynomials
+H0(x) = 1
+H1(x) = 2*x
+H2(x) = 4*x*x-2
+H10(x) = -30240 + x*(0 + x*(302400 + x*(0 + x*(-403200 + x*(0 + x*(161280 + x*(0 + x*(-23040 + x*(0 + x*1024)))))))))
+
+# Normalization constant
+coef(n) = sqrt(1.0/2**n/gamma(n+1)/sqrt(pi))
+
+psi0(x) = coef(0)*exp(-x*x/2)*H0(x)
+psi1(x) = coef(1)*exp(-x*x/2)*H1(x)
+psi2(x) = coef(2)*exp(-x*x/2)*H2(x)
+psi10(x) = coef(10)*exp(-x*x/2)*H10(x)
+
+set ylabel 'psi(x)'
+
+set pointsize 1
+
+set origin 0, 0.5
+plot psi0(x) title 'Exact: n = 0', "qhoscillator.dat" u 1:2 pt 7 title 'Numerical'
+
+set origin 0.5, 0.5
+plot psi1(x) title 'Exact: n = 1', "qhoscillator.dat" u 1:3 pt 7 title 'Numerical'
+
+set origin 0, 0
+plot psi2(x) title 'Exact: n = 2', "qhoscillator.dat" u 1:4 pt 7title 'Numerical'
+
+set origin 0.5, 0
+plot psi10(x) title 'Exact: n = 10', "qhoscillator.dat" u 1:5 pt 7 title 'Numerical'

data/examples/eigen/qhoscillator.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+#  Harmonic oscillator in quantum mechanics
+#
+#  This example is taken from "eigen1.cpp"
+#  in "Numerische Physik" p214-216 (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")
+
+STDERR.puts("Harmonic oscillator in quantum mechanics:")
+
+# Values used in the book:
+#NMAX = 512
+#dx = 0.02
+
+# These are much faster:
+NMAX = 64
+dx = 0.16
+
+# Potential
+V = GSL::Vector[NMAX]
+for n in 0...NMAX do
+  x = (n - NMAX/2)*dx
+  V[n] = 0.5*x*x
+end
+
+# Hamiltonian
+H = GSL::Matrix.calloc(NMAX, NMAX)
+H.set_diagonal(1.0/dx/dx + V)
+tmp = -0.5/dx/dx
+for n1 in 1...NMAX do
+  H[n1-1,n1] = tmp
+  H[n1,n1-1] = tmp
+end
+for n1 in 0...(NMAX-1) do
+  H[n1+1,n1] = tmp
+  H[n1,n1+1] = tmp
+end
+
+# Calculate eigen values and eigen vectors
+STDERR.print("  Solving the eigen system of #{NMAX}X#{NMAX} dimensions...")
+STDERR.flush
+eval, evec = H.eigen_symmv
+GSL::Eigen.symmv_sort(eval, evec, GSL::Eigen::SORT_VAL_ASC)
+STDERR.puts("OK")
+STDERR.flush
+
+x2 = GSL::Vector[NMAX]
+for n1 in 0...NMAX do
+  x2[n1] = 0
+  for n2 in 0...NMAX do
+    x = (n2 - NMAX/2)*dx
+    x2[n1] += GSL::pow_2(evec[n2,n1]*x)
+  end
+end
+
+# Energy eigen values, see p217 "Tabelle 5.1"
+# The differences with Tabelle 5.1 are from NMAX and dx.
+# If we use NMAX=512 and dx=0.02, we obtain the same results (but much slower).
+STDERR.puts("  Eigen values:")
+STDERR.printf("  %2s Exact %5s %10s | %2s Exact %5s %10s\n", 
+              "n", "E", "err\(\%\)", "n", "E", "err\(\%\)")
+STDERR.print("  -----------------------------------------------------\n")
+for n1 in 0..6 do
+  exact1 = n1 + 0.5
+  exact2 = n1 + 7 + 0.5
+  STDERR.printf("  %2d %4.1f %8.5f %+7.5f | %2d %4.1f %8.5f %+7.5f\n", 
+                n1, exact1, eval[n1], (exact1 - eval[n1])/exact1*100,
+                n1+7, exact2, eval[n1+7], (exact2-eval[n1+7])/exact2*100)
+end
+STDERR.flush
+
+# Eigen vectors of n = 0, 1, 2, 10. See p217 "Abb 5.3"
+c = Math::sqrt(1.0/dx)
+vec0 = evec.col(0).scale(c)    
+vec1 = evec.col(1).scale(c)
+vec2 = evec.col(2).scale(c)
+vec10 = evec.col(10).scale(c)
+File.open("qhoscillator.dat", "w") do |fp|
+  for i in 0...NMAX do
+    x = (i - NMAX/2)*dx
+    fp.printf("%e %e %e %e %e\n", x, -vec0[i], vec1[i], -vec2[i], -vec10[i])
+  end
+end
+system("gnuplot -persist qhoscillator.gp")
+File.delete("qhoscillator.dat")
+