rb-gsl 1.15.3.1

data/examples/fft/sunspot.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# Analysis of the solar activity of 11-years cycle
+# from the number of sunspots.
+# This example is taken from the MATLAB user's manual Chap 13.
+
+require("gsl")
+
+year, sunspot = GSL::Vector.filescan("sunspot.dat")
+N = year.size
+ffted = sunspot.fft
+
+#power = GSL.sqrt(ffted[1..(N-2)].to_complex2.abs2)*2/N
+power = GSL.sqrt(ffted.to_complex2.abs2)*2/N
+freq = GSL::Vector.linspace(1, N/2, power.size)/N
+period = 1.0/freq
+GSL::graph(period, power, "-C -g 3 -x 0 40 -X 'Period [year]'")

data/examples/fit/expdata.dat

@@ -0,0 +1,20 @@
+0 6.02678 0.2
+1 5.50657 0.2
+2 5.42854 0.2
+3 4.85082 0.2
+4 4.55111 0.2
+5 3.77715 0.2
+6 3.26472 0.2
+7 3.34707 0.2
+8 3.23883 0.2
+9 3.21156 0.2
+10 2.83587 0.2
+11 2.40504 0.2
+12 2.37237 0.2
+13 2.399 0.2
+14 2.39919 0.2
+15 2.006 0.2
+16 1.88188 0.2
+17 1.91484 0.2
+18 1.69252 0.2
+19 1.58229 0.2

data/examples/fit/expfit.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+N = 40
+
+amp0 = 5.0
+b0 = 0.1
+y0 = 1.0
+
+r = GSL::Rng.alloc()
+x = GSL::Vector[0...N]
+sigma = GSL::Vector[N]
+sigma.set_all(0.1)
+y = y0 + amp0*GSL::Sf::exp(-b0*x) + 0.1*r.gaussian(1, N)
+
+coef, err, chi2, dof = GSL::MultiFit::FdfSolver.fit(x, sigma, y, "exponential")
+y0 = coef[0]
+amp = coef[1]
+b = coef[2]
+p coef
+p err
+GSL::graph(x, y, y0+amp*GSL::Sf::exp(-b*x))
+
+# This will result in
+# [ 1.019e+00 5.045e+00 1.040e-01 ] 
+# [ 3.385e-02 5.395e-02 2.826e-03 ]
+
+# GNUPLOT results:
+# y0              = 1.01925          +/- 0.03383      (3.319%)
+# A               = 5.04536          +/- 0.05396      (1.069%)
+# b               = 0.104049         +/- 0.002826     (2.716%)

data/examples/fit/gaussfit.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+# Create data
+r = GSL::Rng.alloc("knuthran")
+sigma = 1.5
+x0 = 1.0
+amp = 2.0
+y0 = 3.0
+N = 100
+x = GSL::Vector.linspace(-4, 6, N)
+y = y0 + amp*GSL::Ran::gaussian_pdf(x - x0, sigma) + 0.02*GSL::Ran::gaussian(r, 1.0, N)
+
+coef, err, chi2, dof =  GSL::MultiFit::FdfSolver.fit(x, y, "gaussian")
+sigma2 = Math::sqrt(coef[3])
+x02 = coef[2]
+amp2 = coef[1]*Math::sqrt(2*Math::PI)*sigma
+y02 = coef[0]
+y2 = y02 + amp2*GSL::Ran::gaussian_pdf(x - x02, sigma2)
+
+GSL::graph(x, y, y2, "-C -g 3 -x -4 6")
+
+printf("Expect:\n")
+printf("sigma = #{sigma}, x0 = #{x0}, amp = #{amp}, y0 = #{y0}\n")
+printf("Result:\n")
+printf("sigma = %5.4e +/- %5.4e\n", sigma2, err[3])
+printf("   x0 = %5.4e +/- %5.4e\n", x02, err[2])
+printf("  amp = %5.4e +/- %5.4e\n", amp2, err[1])
+printf("   y0 = %5.4e +/- %5.4e\n", y02, err[0])

data/examples/fit/gaussian_2peaks.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+# Create data
+r = GSL::Rng.alloc("knuthran")
+amp1 = 5.0
+x01 = 1.0
+sigma1 = 1.5
+
+amp2 = 2.0
+x02 = 5.0
+sigma2 = 0.5
+
+y0 = 2.0
+N = 300
+x = GSL::Vector.linspace(-4, 9, N)
+y = y0 + amp1*GSL::Ran::gaussian_pdf(x - x01, sigma1) + amp2*GSL::Ran::gaussian_pdf(x - x02, sigma2) + 0.05*GSL::Ran::gaussian(r, 1.0, N)
+
+coef, err, chi2, dof =  GSL::MultiFit::FdfSolver.fit(x, y, "gaussian_2peak", [2, 4, 0.9, 1, 1, 4, 1])
+
+p coef
+y01 = coef[0]
+
+amp1 = coef[1]*Math::sqrt(2*Math::PI)*sigma1
+x01 = coef[2]
+sigma1 = Math::sqrt(coef[3])
+
+amp2 = coef[4]*Math::sqrt(2*Math::PI)*sigma2
+x02 = coef[5]
+sigma2 = Math::sqrt(coef[6])
+
+y2 = y01 + amp1*GSL::Ran::gaussian_pdf(x - x01, sigma1) + amp2*GSL::Ran::gaussian_pdf(x - x02, sigma2)
+
+GSL::graph(x, y, y2, "-C -g 3")

data/examples/fit/hillfit.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL::MultiFit
+
+N = 100
+
+y0 = 1
+m = 2.0
+xhalf = 5
+rr = 4
+
+r = GSL::Rng.alloc()
+x = GSL::Vector.linspace(0.001, 10, N)
+y =  y0 + (m-y0)/(1.0 + GSL::pow(xhalf/x, rr)) + 0.02*r.gaussian(1, N)
+
+coef, err, chi2, dof = GSL::MultiFit::FdfSolver.fit(x, y, "hill")
+y0 = coef[0]
+m = coef[1]
+xhalf = coef[2]
+rr = coef[3]
+p coef
+p err
+GSL::graph(x, y, y0+(m-y0)/(1+GSL::pow(xhalf/x, rr)))
+
+=begin
+Result:
+GSL::Vector
+[ 9.959e-01 1.995e+00 4.936e+00 4.035e+00 ]
+GSL::Vector
+[ 4.676e-03 1.035e-02 3.779e-02 1.125e-01 ]
+
+GNUPLOT result:
+Final set of parameters            Asymptotic Standard Error
+=======================            ==========================
+
+y0              = 0.995858         +/- 0.004676     (0.4695%)
+m               = 1.99465          +/- 0.01034      (0.5184%)
+xhalf           = 4.93605          +/- 0.0378       (0.7658%)
+r               = 4.0346           +/- 0.1124       (2.787%)
+=end

data/examples/fit/lognormal.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+N = 100
+
+y0 = 1.0
+A = 2.0
+x0 = 3.0
+w = 0.5
+
+r = GSL::Rng.alloc()
+x = GSL::Vector.linspace(0.01, 10, N)
+sig = 1
+y =  y0 + A*GSL::Sf::exp(-GSL::pow_2(GSL::Sf::log(x/x0)/w)) + 0.1*GSL::Ran::gaussian(r, sig, N)
+
+coef, err, chi2, dof = GSL::MultiFit::FdfSolver.fit(x, y, "lognormal", [0, 3, 2, 1])
+y0 = coef[0]
+amp = coef[1]
+x0 = coef[2]
+w = coef[3]
+
+p coef
+p err
+
+GSL::graph(x, y, y0+amp*GSL::Sf::exp(-GSL::pow_2(GSL::Sf::log(x/x0)/w)))
+

data/examples/fit/lorentzfit.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+N = 100
+
+y0 = 1.0
+A = 2.0
+x0 = 3.0
+B = 4.0
+
+r = GSL::Rng.alloc()
+x = GSL::Vector.linspace(-10, 20, N)
+y =  y0 + A/(GSL::pow_2(x-x0)+B) + 0.03*GSL::Ran::gaussian(r, 1, N)
+
+coef, err, chi2, dof = GSL::MultiFit::FdfSolver.fit(x, y, "lorentzian")
+y0 = coef[0]
+amp = coef[1]
+x0 = coef[2]
+b = coef[3]
+p coef
+p err
+GSL::graph(x, y, y0+amp/(GSL::pow_2(x-x0)+b))

data/examples/fit/multifit.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+GSL::Rng.env_setup()
+  
+r = GSL::Rng.alloc(GSL::Rng::DEFAULT)
+
+n = 19
+dim = 3
+X = GSL::Matrix.alloc(n, dim)
+y = GSL::Vector.alloc(n)
+w = GSL::Vector.alloc(n)
+
+file0 = "data.dat"
+file1 = "fit.dat"
+
+a = 0.1
+File.open(file0, "w") do |f|
+  for i in 0...n
+    y0 = Math::exp(a)
+    sigma = 0.1*y0
+    val = r.gaussian(sigma)
+    X[i,0] = 1.0
+    X[i,1] = a
+    X[i,2] = a*a
+    y[i] = y0 + val
+    w[i] = 1.0/(sigma*sigma)
+    f.printf("%g %g %g\n", a, y[i], sigma)
+    a += 0.1
+  end
+end
+
+c, cov, chisq, status = GSL::MultiFit.wlinear(X, w, y)
+
+printf("# best fit: Y = %g + %g X + %g X^2\n", c[0], c[1], c[2])
+printf("# covariance matrix:\n")
+printf("[ %+.5e, %+.5e, %+.5e\n", cov[0,0], cov[0,1], cov[0,2])
+printf("  %+.5e, %+.5e, %+.5e\n", cov[1,0], cov[1,1], cov[1,2])
+printf("  %+.5e, %+.5e, %+.5e ]\n", cov[2,0], cov[2,1], cov[2,2])
+printf("# chisq = %g\n", chisq)
+
+str = sprintf("%4.3f", c[0])
+if c[1] > 0.0
+  str += sprintf("+ %4.3f*x", c[1].abs)
+else
+  str += sprintf("- %4.3f*x", c[1].abs)
+end
+if c[2] > 0.0
+  str += sprintf("+ %4.3f*x*x", c[2].abs)
+else
+  str += sprintf("- %4.3f*x*x", c[2].abs)
+end
+
+func = GSL::Function.alloc { |x, params|
+  c0 = params[0]; c1 = params[1]; c2 = params[2]
+  c0 + x*(c1 + x*c2)
+}
+
+func.set_params(c)
+
+File.open(file1, "w") do |f|
+  x = 0
+  while x < 2
+    f.printf("%e %e\n", x, func.eval(x))
+    x += 0.01
+  end
+end
+
+system("graph -T X -C -g 3 -y 0 7 -L '#{str}' -I e -m -1 -S 4 data.dat -I a -m 2 -S 0 fit.dat")
+
+File.delete(file0)
+File.delete(file1)

data/examples/fit/ndlinear.rb

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+unless GSL::MultiFit.const_defined?("Ndlinear")
+	puts("The extension library NDLINEAR is not installed.")
+	exit()
+end
+
+N_DIM = 3
+N_SUM_R = 10
+N_SUM_THETA = 11
+N_SUM_PHI = 9
+R_MAX = 3.0
+
+def psi_real_exact(k, l, m, r, theta, phi)
+  rr = GSL::pow(r, l)*Math::exp(-r*r)*GSL::Sf::laguerre_n(k, l + 0.5, 2 * r * r)	 
+
+	tt = GSL::Sf::legendre_sphPlm(l, m, Math::cos(theta))
+
+	pp = Math::cos(m*phi)
+
+	rr*tt*pp
+end
+
+basis_r = Proc.new { |r, y, params|
+	params.eval(r, y)
+}
+
+basis_theta = Proc.new { |theta, y, params|
+	for i in 0...N_SUM_THETA do
+		y[i] = GSL::Sf::legendre_Pl(i, Math::cos(theta));
+	end
+}
+
+basis_phi = Proc.new { |phi, y, params|
+	for i in 0...N_SUM_PHI do
+		if i%2 == 0
+			y[i] = Math::cos(i*0.5*phi)
+		else
+			y[i] = Math::sin((i+1.0)*0.5*phi)
+		end
+	end
+}
+
+
+GSL::Rng::env_setup()
+
+k = 5
+l = 4
+m = 2
+
+NDATA = 3000
+
+N = [N_SUM_R, N_SUM_THETA, N_SUM_PHI]
+u = [basis_r, basis_theta, basis_phi]
+
+rng = GSL::Rng.alloc()
+
+bspline = GSL::BSpline.alloc(4, N_SUM_R - 2)
+bspline.knots_uniform(0.0, R_MAX)
+
+ndlinear = GSL::MultiFit::Ndlinear.alloc(N_DIM, N, u, bspline)
+multifit = GSL::MultiFit.alloc(NDATA, ndlinear.n_coeffs)
+vars = GSL::Matrix.alloc(NDATA, N_DIM)
+data = GSL::Vector.alloc(NDATA)
+
+
+for i in 0...NDATA do
+
+	r = rng.uniform()*R_MAX
+	theta = rng.uniform()*Math::PI
+	phi = rng.uniform()*2*Math::PI
+
+	psi = psi_real_exact(k, l, m, r, theta, phi)
+
+	dpsi = rng.gaussian(0.05*psi)
+
+	vars[i,0] = r
+	vars[i,1] = theta
+	vars[i,2] = phi		
+
+	data[i] = psi + dpsi
+end
+
+#GSL::MultiFit::Ndlinear::design(vars, X, ndlinear)
+X = GSL::MultiFit::Ndlinear::design(vars, ndlinear)
+
+coeffs, cov, chisq, = GSL::MultiFit::linear(X, data, multifit)
+
+rsq = GSL::MultiFit::linear_Rsq(data, chisq)
+STDERR.printf("chisq = %e, Rsq = %f\n", chisq, rsq)
+
+eps_rms = 0.0
+volume = 0.0
+dr = 0.05;
+dtheta = 5.0 * Math::PI / 180.0
+dphi = 5.0 * Math::PI / 180.0
+x = GSL::Vector.alloc(N_DIM)
+
+r = 0.01
+while r < R_MAX do
+	theta = 0.0
+	while theta < Math::PI do
+		phi = 0.0
+		while phi < 2*Math::PI do
+			dV = r*r*Math::sin(theta)*dr*dtheta*dphi
+			x[0] = r
+			x[1] = theta
+			x[2] = phi
+
+			psi_model, err = GSL::MultiFit::Ndlinear.calc(x, coeffs, cov, ndlinear)
+			psi = psi_real_exact(k, l, m, r, theta, phi)
+			err = psi_model - psi
+      eps_rms += err * err * dV;
+      volume += dV;
+
+      if phi == 0.0
+         printf("%e %e %e %e\n", r, theta, psi, psi_model)
+      end
+
+			phi += dphi
+		end
+		theta += dtheta
+	end
+	printf("\n");
+
+	r += dr
+end
+
+eps_rms /= volume
+eps_rms = Math::sqrt(eps_rms)
+STDERR.printf("rms error over all parameter space = %e\n", eps_rms)
+

data/examples/fit/nonlinearfit.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+FFF = GSL::Function.alloc { |t, params|
+  a = params[0]; lambda = params[1]; b = params[2]
+  a*Math::exp(-lambda*t) + b
+}
+  
+procf = Proc.new { |x, t, y, sigma, f|
+  a = x[0]; lambda = x[1]; b = x[2]
+  FFF.set_params(x)
+  n = t.size
+  for i in 0...n do
+    yi = FFF.eval(t[i])
+    f[i] = (yi - y[i])/sigma[i]
+  end
+}
+
+procdf = Proc.new { |x, t, y, sigma, jac|
+  a = x[0]; lambda = x[1]
+  n = t.size
+  for i in 0...n do
+    ti = t[i]
+    si = sigma[i]
+    ei = Math::exp(-lambda*ti)
+    jac[i,0] = ei/si
+    jac[i,1] = -ti*a*ei/si
+    jac[i,2] = 1.0/si
+  end
+}
+
+n = 20
+np = 3
+
+f = GSL::MultiFit::Function_fdf.alloc(procf, procdf, np)
+
+r = GSL::Rng.alloc()
+t = GSL::Vector.alloc(n)
+y = GSL::Vector.alloc(n)
+sigma = GSL::Vector.alloc(n)
+File.open("expdata.dat", "w") do |fp|
+  for i in 0...n do
+    t[i] = i
+    y[i] = 1.0 + 5*Math::exp(-0.1*t[i]) + r.gaussian(0.2)
+    sigma[i] = 0.2
+    fp.printf("%d %g %g\n", t[i], y[i], sigma[i])
+#    fp.printf("%d %g\n", t[i], y[i])
+  end
+end
+
+f.set_data(t, y, sigma)
+x = GSL::Vector.alloc([1.0, 0.0, 0.0])
+
+solver = GSL::MultiFit::FdfSolver.alloc(GSL::MultiFit::FdfSolver::LMSDER, n, np)
+#solver = GSL::MultiFit::FdfSolver.alloc(GSL::MultiFit::FdfSolver::LMDER, n, np)
+solver.set(f, x)
+
+iter = 0
+solver.print_state(iter)
+begin
+  iter += 1
+  status = solver.iterate
+  solver.print_state(iter)
+  status = solver.test_delta(1e-4, 1e-4)
+end while status == GSL::CONTINUE and iter < 500
+
+covar = solver.covar(0.0)
+position = solver.position
+
+chi2 = GSL::pow_2(solver.f.dnrm2)
+dof = n - np
+printf("A      = %.5f +/- %.5f\n", position[0], Math::sqrt(chi2/dof*covar[0,0]))
+printf("lambda = %.5f +/- %.5f\n", position[1], Math::sqrt(chi2/dof*covar[1,1]))
+printf("b      = %.5f +/- %.5f\n", position[2], Math::sqrt(chi2/dof*covar[2,2]))
+
+str = sprintf("%4.3f*exp(-%4.3f*x)+%4.3f", position[0], position[1], position[2])
+
+FFF.set_params(position)
+x = 0
+File.open("fit.dat", "w") do |f|
+  while x < 40
+    f.printf("%e %e\n", x, FFF.eval(x))
+    x += 0.1
+  end
+end
+
+system("graph -T X -C -g 3 -L '#{str}' -X x -I e -m -1 -S 4 expdata.dat -I a -m 2 -S 0 fit.dat")
+#File.delete("expdata.dat")
+#File.delete("fit.dat")