rb-gsl 1.15.3.1

data/tests/monte/miser.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+require("gsl")
+require("../gsl_test2.rb")
+include GSL::Test
+
+exit unless GSL::Monte::Miser.method_defined?("params_get")
+
+dim = 1
+miser = GSL::Monte::Miser.alloc(dim)
+
+params = miser.params_get
+
+params.estimate_frac = 99
+miser.params_set(params)
+test_abs(miser.estimate_frac, 99, 1e-5, "miser_estimate_frac")
+
+params.min_calls = 9
+miser.params_set(params)
+test_int(miser.min_calls, 9, "miser_min_calls")
+
+params.min_calls_per_bisection = 7
+miser.params_set(params)
+test_int(miser.min_calls_per_bisection, 7, "miser_min_calls_per_bisection")
+
+params.alpha = 3
+miser.params_set(params)
+test_abs(miser.alpha, 3, 1e-5, "miser_alpha")
+
+params.dither = 4
+miser.params_set(params)
+test_abs(miser.dither, 4, 1e-5, "miser_dither")

data/tests/monte/vegas.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+require("gsl")
+require("../gsl_test2.rb")
+include GSL::Test
+
+exit unless GSL::Monte::Vegas.method_defined?("params_get")
+
+dim = 1
+vegas = GSL::Monte::Vegas.alloc(dim)
+
+params = vegas.params_get
+
+params.alpha = 1
+vegas.params_set(params)
+test_abs(vegas.alpha, 1, 1e-5, "vegas_alpha")
+
+params.iterations = 4
+vegas.params_set(params)
+test_int(vegas.iterations, 4, "vegas_iterations")
+
+params.stage = 3
+vegas.params_set(params)
+test_int(vegas.stage, 3, "vegas_stage")
+
+params.mode = GSL::Monte::Vegas::MODE_IMPORTANCE
+vegas.params_set(params)
+test_int(vegas.mode, GSL::Monte::Vegas::MODE_IMPORTANCE, "vegas_mode MODE_IMPORTANCE")
+
+params.mode = GSL::Monte::Vegas::MODE_IMPORTANCE_ONLY
+vegas.params_set(params)
+test_int(vegas.mode, GSL::Monte::Vegas::MODE_IMPORTANCE_ONLY, "vegas_mode MODE_IMPORTANCE_ONLY")
+
+params.mode = GSL::Monte::Vegas::MODE_STRATIFIED
+vegas.params_set(params)
+test_int(vegas.mode, GSL::Monte::Vegas::MODE_STRATIFIED, "vegas_mode MODE_STRATIFIED")
+
+params.verbose = 0
+vegas.params_set(params)
+test_int(vegas.verbose, 0, "vegas_verbose 0")
+params.verbose = 1
+vegas.params_set(params)
+test_int(vegas.verbose, 1, "vegas_verbose 1")
+params.verbose = -1
+vegas.params_set(params)
+test_int(vegas.verbose, -1, "vegas_verbose -1")

data/tests/multifit/test_2dgauss.rb

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+# vim: set ts=8 sw=2 sts=2:
+#require("gsl")
+#require("../gsl_test2.rb")
+require("./test_multifit.rb")
+include GSL::Test
+include Math
+
+Maxiter = 10
+N = 33
+
+# point
+class Point
+  attr_accessor :x, :y
+  def initialize(x = nil, y = nil)
+    @x, @y = x, y
+  end
+end
+
+# model: a*exp(-((x-x0)**2+(y-y0)**2)/2/sigma**2)
+gauss_f = Proc.new { |x, t, y, s, f|
+  # x: parameters as a Vecor
+  # t: observed points as an Array
+  # y: observed data as a GSL::Vector
+  # s: errorbar
+  # f: result
+  a = x[0]
+  x0 = x[1]
+  y0 = x[2]
+  sigma2 = x[3]**2
+  y.size.times do |i|
+    f.set(i, (a*Math::exp(-((t[i].x - x0)**2+(t[i].y - y0)**2)/2/sigma2) - y[i])/s[i])
+  end
+  GSL::SUCCESS
+}
+
+gauss_df = Proc.new { |x, t, y, s, df|
+  a = x[0]
+  x0 = x[1]
+  y0 = x[2]
+  sigma = x[3]
+  sigma2 = sigma**2
+  y.size.times do |i|
+    dx = t[i].x - x0; dx2 = dx**2
+    dy = t[i].y - y0; dy2 = dy**2
+    f = a*Math::exp(-(dx2+dy2)/2/sigma2)
+    df.set(i, 0, f/a/s[i])
+    df.set(i, 1, f*dx/sigma2/s[i])
+    df.set(i, 2, f*dy/sigma2/s[i])
+    df.set(i, 3, f*(dx2+dy2)/sigma2/sigma/s[i])
+  end
+  GSL::SUCCESS
+}
+
+# goal
+xgoal = GSL::Vector.alloc([1, 0, 0, 1])
+parname = %w( a x0 y0 si )
+
+# data
+t = Array.new
+tmin = -10.0
+tmax = 10.0
+N.times do |j|
+  N.times do |i|
+    t << Point.new(tmin + (tmax - tmin)*i/(N-1), tmin + (tmax - tmin)*j/(N-1))
+  end
+end
+stdev = xgoal[0]*0.1 
+s = GSL::Vector.alloc(Array.new(t.size, stdev))  # error bar of each datum
+r = Rng.alloc
+e = GSL::Vector.alloc(t.size)
+t.size.times do |i|
+  e[i] = -r.gaussian(stdev)	# perturbation to data
+end
+y = GSL::Vector.alloc(t.size)
+n = GSL::Vector.alloc(Array.new(t.size, 1.0))
+gauss_f.call(xgoal, t, e, n, y)  # data: y = model - e
+
+# fitting
+x = GSL::Vector.alloc([0.5, 0.1, -0.1, 2.0]) # initial guess
+fdf = GSL::MultiFit::Function_fdf.alloc(gauss_f, gauss_df, x.size)
+fdf.set_data(t, y, s)
+
+solver = GSL::MultiFit::FdfSolver.alloc(GSL::MultiFit::FdfSolver::LMSDER, t.size, x.size)
+solver.set(fdf, x)
+
+solver.print_state(0)
+Maxiter.times do |i|
+  solver.iterate
+  status = solver.test_delta(1e-6, 1e-6)
+  solver.print_state(i+1)
+  break unless GSL::CONTINUE == status
+end
+
+# results
+covar = solver.covar(0.0)
+xresult = solver.position
+dof = t.size - xresult.size
+chi2 = pow_2(solver.f.dnrm2)
+xsigma = GSL::Vector.alloc(xresult.size)
+xresult.size.times do |i|
+  xsigma[i] = Math::sqrt(chi2/dof*covar[i,i]) * 2.0
+  # allow resulting parameters to differ two times than standard error
+end
+puts "a*exp(-((x-x0)**2+(y-y0)**2)/2/si**2), chi2/N:%.3g" % (chi2/t.size)
+xresult.size.times do |i|
+  test_rel(xresult[i], xgoal[i], xsigma[i], "%-2.2s" % parname[i])
+  if (xresult[i] - xgoal[i]).abs > xsigma[i] then
+    puts "#{'%-2.2s' % parname[i]} is #{xresult[i]} +- #{xsigma[i]}"
+    exit 1
+  end
+end

data/tests/multifit/test_brown.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+#require("gsl")
+#require("../gsl_test2.rb")
+require("./test_multifit.rb")
+include GSL::Test
+include Math
+
+Brown_N = 20;
+Brown_P = 4;
+
+Brown_X = GSL::Matrix.alloc([24.3485677, 4.71448798, -2.19486633, 2.69405755],
+  [22.4116222, 3.93075538, -1.42344852, 2.5233557],
+  [17.88886, 2.9290853, 0.125174936, -3.96823353],
+  [17.3237176, 2.99606803, 2.03285653, 2.28992327],
+  [17.0906508, 3.02485425, 0.296995153, 0.0876226126],
+  [16.578006, 3.1036312, -0.18617941, 0.103262914],
+  [15.692993, 3.33088442, 0.0706406887, 1.05923955],
+  [14.3232177, 3.85604218, -2.3762839, -3.09486813],
+  [14.1279266, 3.97896121, 0.446109351, 1.40023753],
+  [13.6081961, 4.16435075, -1.51250057, -1.52510626],
+  [13.4295245, 4.22697223, -0.196985195, 0.532009293],
+  [13.0176117, 4.3579261, -0.353131208, 0.301377627],
+  [12.2713535, 4.62398535, -0.00183585584, 0.894170703],
+  [11.0316144, 5.13967727, -2.38978772, -2.89510064],
+  [10.8807981, 5.24558004, 0.230495952, 1.27315117],
+  [10.4029264, 5.41141257, -1.5116632, -1.47615921],
+  [10.2574435, 5.46211045, -0.299855732, 0.451893162],
+  [9.87863876, 5.57914292, -0.368885288, 0.358086545],
+  [9.1894983, 5.82082741, -0.230157969, 0.621476534],
+  [8.00589008, 6.27788753, -1.46022815, -1.33468082])
+
+Brown_F = GSL::Vector.alloc(
+                     2474.05541,
+                     1924.69004,
+                     1280.63194,
+                     1244.81867,
+                     1190.53739,
+                     1159.34935,
+                     1108.44426,
+                     1090.11073,
+                     1015.92942,
+                     1002.43533,
+                     971.221084,
+                     949.589435,
+                     911.359899,
+                     906.522994,
+                     840.525729,
+                     833.950164,
+                     807.557511,
+                     791.00924,
+                     761.09598,
+                     726.787783)
+
+Brown_cov = GSL::Matrix.alloc(
+                       [ 1.8893186910e-01, -4.7099989571e-02,  5.2154168404e-01,  1.6608168209e-02],
+                       [-4.7099989571e-02,  1.1761534388e-02, -1.2987843074e-01, -4.1615942391e-03],
+                       [ 5.2154168404e-01, -1.2987843074e-01,  1.4653936514e+00,  1.5738321686e-02],
+                       [ 1.6608168209e-02, -4.1615942391e-03,  1.5738321686e-02,  4.2348042340e-02]
+                     )
+
+Brown_x0 = GSL::Vector.alloc(25, 5, -5, -1)
+
+brown_f = Proc.new { |x, t, y, f|
+  for i in 0...Brown_N
+    ti = 0.2 * (i + 1);
+    ui = x[0] + x[1] * ti - exp(ti);
+    vi = x[2] + x[3] * sin(ti) - cos(ti);
+    f[i] = ui*ui + vi*vi
+  end
+  GSL::SUCCESS
+}
+
+brown_df = Proc.new { |x, t, y, df|
+  for i in 0...Brown_N
+    ti = 0.2 * (i + 1);
+    ui = x[0] + x[1] * ti - exp(ti);
+    vi = x[2] + x[3] * sin(ti) - cos(ti);
+    df.set(i, 0, 2.0*ui)
+    df.set(i, 1, 2.0*ui*ti)
+    df.set(i, 2, 2.0*vi)
+    df.set(i, 3, 2.0*vi*sin(ti))
+  end
+  GSL::SUCCESS
+}
+
+fdf = GSL::MultiFit::Function_fdf.alloc(brown_f, brown_df, Brown_P)
+
+fdf.set_data(GSL::Vector.alloc(Brown_N), GSL::Vector.alloc(Brown_N))
+
+test_lmder(fdf, Brown_x0, Brown_X.vector_view, Brown_F, Brown_cov.vector_view)

data/tests/multifit/test_enso.rb

@@ -0,0 +1,246 @@
+#!/usr/bin/env ruby
+#require("gsl")
+#require("../gsl_test2.rb")
+require("./test_multifit.rb")
+include GSL::Test
+include Math
+
+Enso_N = 168;
+Enso_P = 9;
+
+Enso_x0 = GSL::Vector.alloc(10.0, 3.0, 0.5, 44.0, -1.5, 0.5, 26.0, 0.1, 1.5)
+
+Enso_x = GSL::Vector.alloc(
+                    1.0510749193E+01, 
+                    3.0762128085E+00,
+                    5.3280138227E-01,
+                    4.4311088700E+01,
+                    -1.6231428586E+00,
+                    5.2554493756E-01,
+                    2.6887614440E+01,
+                    2.1232288488E-01,
+                    1.4966870418E+00)
+
+Enso_sumsq = 7.8853978668E+02
+
+Enso_sigma = GSL::Vector.alloc(
+                        1.7488832467E-01,
+                        2.4310052139E-01,
+                        2.4354686618E-01,
+                        9.4408025976E-01,
+                        2.8078369611E-01,
+                        4.8073701119E-01,
+                        4.1612939130E-01,
+                        5.1460022911E-01,
+                        2.5434468893E-01)
+
+Enso_F = GSL::Vector.alloc(    
+                   12.90000, 
+    11.30000, 
+    10.60000, 
+    11.20000, 
+    10.90000, 
+    7.500000, 
+    7.700000, 
+    11.70000, 
+    12.90000, 
+    14.30000, 
+    10.90000, 
+    13.70000, 
+    17.10000, 
+    14.00000, 
+    15.30000, 
+    8.500000, 
+    5.700000, 
+    5.500000, 
+    7.600000, 
+    8.600000, 
+    7.300000, 
+    7.600000, 
+    12.70000, 
+    11.00000, 
+    12.70000, 
+    12.90000, 
+    13.00000, 
+    10.90000, 
+   10.400000, 
+   10.200000, 
+    8.000000, 
+    10.90000, 
+    13.60000, 
+   10.500000, 
+    9.200000, 
+    12.40000, 
+    12.70000, 
+    13.30000, 
+   10.100000, 
+    7.800000, 
+    4.800000, 
+    3.000000, 
+    2.500000, 
+    6.300000, 
+    9.700000, 
+    11.60000, 
+    8.600000, 
+    12.40000, 
+   10.500000, 
+    13.30000, 
+   10.400000, 
+    8.100000, 
+    3.700000, 
+    10.70000, 
+    5.100000, 
+   10.400000, 
+    10.90000, 
+    11.70000, 
+    11.40000, 
+    13.70000, 
+    14.10000, 
+    14.00000, 
+    12.50000, 
+    6.300000, 
+    9.600000, 
+    11.70000, 
+    5.000000, 
+    10.80000, 
+    12.70000, 
+    10.80000, 
+    11.80000, 
+    12.60000, 
+    15.70000, 
+    12.60000, 
+    14.80000, 
+    7.800000, 
+    7.100000, 
+    11.20000, 
+    8.100000, 
+    6.400000, 
+    5.200000, 
+    12.00000, 
+   10.200000, 
+    12.70000, 
+   10.200000, 
+    14.70000, 
+    12.20000, 
+    7.100000, 
+    5.700000, 
+    6.700000, 
+    3.900000, 
+    8.500000, 
+    8.300000, 
+    10.80000, 
+    16.70000, 
+    12.60000, 
+    12.50000, 
+    12.50000, 
+    9.800000, 
+    7.200000, 
+    4.100000, 
+    10.60000, 
+   10.100000, 
+   10.100000, 
+    11.90000, 
+    13.60000, 
+    16.30000, 
+    17.60000, 
+    15.50000, 
+    16.00000, 
+    15.20000, 
+    11.20000, 
+    14.30000, 
+    14.50000, 
+    8.500000, 
+    12.00000, 
+    12.70000, 
+    11.30000, 
+    14.50000, 
+    15.10000, 
+   10.400000, 
+    11.50000, 
+    13.40000, 
+    7.500000, 
+   0.6000000, 
+   0.3000000, 
+    5.500000, 
+    5.000000, 
+    4.600000, 
+    8.200000, 
+    9.900000, 
+    9.200000, 
+    12.50000, 
+    10.90000, 
+    9.900000, 
+    8.900000, 
+    7.600000, 
+    9.500000, 
+    8.400000, 
+    10.70000, 
+    13.60000, 
+    13.70000, 
+    13.70000, 
+    16.50000, 
+    16.80000, 
+    17.10000, 
+    15.40000, 
+    9.500000, 
+    6.100000, 
+   10.100000, 
+    9.300000, 
+    5.300000, 
+    11.20000, 
+    16.60000, 
+    15.60000, 
+    12.00000, 
+    11.50000, 
+    8.600000, 
+    13.80000, 
+    8.700000, 
+    8.600000, 
+    8.600000, 
+    8.700000, 
+    12.80000, 
+    13.20000, 
+    14.00000, 
+    13.40000, 
+                        14.80000)
+
+
+enso_f = Proc.new { |x, t, y, f|
+  b = x
+  for i in 0...Enso_N
+    ti = t[i]
+    yy = b[0]
+    yy += b[1]*cos(2.0*M_PI*ti/12)
+    yy += b[2]*sin(2.0*M_PI*ti/12)
+    yy += b[4]*cos(2.0*M_PI*ti/b[3])
+    yy += b[5]*sin(2.0*M_PI*ti/b[3])
+    yy += b[7]*cos(2.0*M_PI*ti/b[6])
+    yy += b[8]*sin(2.0*M_PI*ti/b[6])
+    f[i] = y[i] - yy
+  end
+  GSL::SUCCESS
+}
+
+enso_df = Proc.new { |x, t, y, df|
+  b = x
+  for i in 0...Enso_N
+    ti = t[i]
+    df.set(i, 0, -1.0)
+    df.set(i, 1, -cos(2.0*M_PI*ti/12))
+    df.set(i, 2, -sin(2.0*M_PI*ti/12))
+    df.set(i, 3, -b[4]*(2.0*M_PI*ti/(b[3]*b[3]))*sin(2*M_PI*ti/b[3])+ b[5]*(2*M_PI*ti/(b[3]*b[3]))*cos(2*M_PI*ti/b[3]))
+    df.set(i, 4, -cos(2*M_PI*ti/b[3]));
+    df.set(i, 5, -sin(2*M_PI*ti/b[3]));
+    df.set(i, 6,  - b[7] * (2*M_PI*ti/(b[6]*b[6])) * sin(2*M_PI*ti/b[6]) + b[8] * (2*M_PI*ti/(b[6]*b[6])) * cos(2*M_PI*ti/b[6]))
+    df.set(i, 7, -cos(2*M_PI*ti/b[6]));
+    df.set(i, 8, -sin(2*M_PI*ti/b[6]));
+  end
+  GSL::SUCCESS
+}
+
+fdf = GSL::MultiFit::Function_fdf.alloc(enso_f, enso_df, Enso_P)
+
+#fdf.set_data(GSL::Vector.alloc(1..168), Enso_F)
+fdf.set_data(GSL::Vector.indgen(168, 1), Enso_F)
+
+test_fdf("nist-ENSO", fdf, Enso_x0, Enso_x, Enso_sumsq, Enso_sigma)