gsl 1.12.109 → 1.14.5

data/tests/multiroot.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+# Ruby/GSL implementation of GSL "multiroot/test.c"
+require("gsl")
+require("./gsl_test2.rb")
+include GSL::Test
+include Math
+
+GC.disable
+
+def test_fdf(desc, fdf, initpt, factor, type)
+  n = fdf.n
+  x = eval("#{initpt}")
+  if factor != 1.0
+    x = x.scale(factor)
+  end
+  s = GSL::MultiRoot::FdfSolver.alloc(type, n)
+  s.set(fdf, x)
+  iter = 0
+  begin
+    iter += 1
+    status = s.iterate
+    status = GSL::MultiRoot.test_residual(s.f, 0.0000001)
+  end while status == GSL::CONTINUE and iter < 1000
+
+  jac, stat = GSL::MultiRoot.fdjacobian(fdf, s.x, s.f, GSL::SQRT_DBL_EPSILON)
+  r = 0.0
+  sum = 0.0
+  for i in 0...n
+    for j in 0...n
+      u = jac[i,j]
+      su = s.jac[i,j]
+      r = (u - su).abs/(1e-6 + 1e-6 * u.abs)
+      sum += r
+      if (u - su).abs > (1e-6 + 1e-6 * u.abs)
+        printf("broken jacobian %g\n", r)
+      end
+    end
+    printf("avg r = %g\n", sum/(n*n))
+  end
+
+  residual = 0.0
+  for i in 0...n
+    residual += s.f[i].abs
+  end
+  GSL::Test::test(status, "#{type} on #{desc} (#{factor}), #{iter} iterations, residual = #{residual}")
+
+end
+
+def test_f(desc, fdf, initpt, factor, type)
+  n = fdf.n
+  x = eval("#{initpt}")
+  x = x.scale(factor)
+  function = GSL::MultiRoot::Function.alloc(fdf.f, fdf.n)
+  s = GSL::MultiRoot::FSolver.alloc(type, n)
+  s.set(function, x)
+  iter = 0
+  begin
+    iter += 1
+    status = s.iterate
+    status = GSL::MultiRoot.test_residual(s.f,  0.0000001)
+  end while status == GSL::CONTINUE and iter < 1000
+  residual = 0.0
+  for i in 0...n
+    residual += s.f[i].abs
+  end
+  GSL::Test::test(status, "#{type} on #{desc} (#{factor}), #{iter} iterations, residual = #{residual}")
+end
+
+def roth_initpt
+  return GSL::Vector.alloc(4.5, 3.5)
+end
+
+def wood_initpt
+  return GSL::Vector.alloc(-3.0, -1.0, -3.0, -1.0)
+end
+
+def rosenbrock_initpt
+  GSL::Vector.alloc(-1.2, 1.0)
+end
+
+roth_f = Proc.new { |x, f|
+  u = x[0]
+  v = x[1]
+  f[0] = -13.0 + u + ((5.0 - v)*v - 2.0)*v;
+  f[1] = -29.0 + u + ((v + 1.0)*v - 14.0)*v;
+}
+
+roth_df = Proc.new { |x, df|
+  x1 = x[1]
+  df.set(0, 0, 1.0)
+  df.set(0, 1, -3 * x1 * x1 + 10 * x1 - 2)
+  df.set(1, 0, 1.0)
+  df.set(1, 1, 3 * x1 * x1 + 2 * x1 - 14)
+}
+
+rosenbrock_f = Proc.new { |x, f|
+  x0 = x[0]; x1 = x[1]
+  y0 = 1.0 - x0
+  y1 = 10*(x1 - x0*x0)
+  f[0] = y0
+  f[1] = y1
+  GSL::SUCCESS
+}
+rosenbrock_df = Proc.new { |x, df|
+  x0 = x[0]
+  df00 = -1.0
+  df01 = 0.0
+  df10 = -20*x0
+  df11 = 10
+  df.set(0, 0, df00)
+  df.set(0, 1, df01)
+  df.set(1, 0, df10)
+  df.set(1, 1, df11)
+  GSL::SUCCESS
+}
+
+roth = GSL::MultiRoot::Function_fdf.alloc(roth_f, roth_df, 2)
+rosenbrock = GSL::MultiRoot::Function_fdf.alloc(rosenbrock_f, rosenbrock_df, 2)
+
+fsolvers = ["dnewton", "broyden", "hybrid", "hybrids"]
+fsolvers.each do |type|
+  test_f("Roth", roth, "roth_initpt", 1.0, type)
+  test_f("Rosenbrock", rosenbrock, "rosenbrock_initpt", 1.0, type)
+end
+
+exit
+f = 1.0
+fdfsolvers = ["newton", "gnewton", "hybridj", "hybridsj"]
+fdfsolvers.each do |type|
+  test_fdf("Roth", roth, "roth_initpt", f, type)
+end

data/tests/multiset.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+require("gsl")
+require("./gsl_test2.rb")
+include GSL::Test
+
+exit if GSL::VERSION < "1.14"
+
+
+c63 = [ [ 0,0,0 ],  [ 0,0,1 ],  [ 0,0,2 ],  [ 0,0,3 ], [ 0,0,4 ],  [ 0,0,5 ],
+              [ 0,1,1 ],  [ 0,1,2 ],  [ 0,1,3 ], [ 0,1,4 ],  [ 0,1,5 ],
+                          [ 0,2,2 ],  [ 0,2,3 ], [ 0,2,4 ],  [ 0,2,5 ],
+                                      [ 0,3,3 ], [ 0,3,4 ],  [ 0,3,5 ],
+                                                 [ 0,4,4 ],  [ 0,4,5 ],
+                                                             [ 0,5,5 ],
+              [ 1,1,1 ],  [ 1,1,2 ],  [ 1,1,3 ], [ 1,1,4 ],  [ 1,1,5 ],
+                          [ 1,2,2 ],  [ 1,2,3 ], [ 1,2,4 ],  [ 1,2,5 ],
+                                      [ 1,3,3 ], [ 1,3,4 ],  [ 1,3,5 ],
+                                                 [ 1,4,4 ],  [ 1,4,5 ],
+                                                             [ 1,5,5 ],
+                          [ 2,2,2 ],  [ 2,2,3 ], [ 2,2,4 ],  [ 2,2,5 ],
+                                      [ 2,3,3 ], [ 2,3,4 ],  [ 2,3,5 ],
+                                                 [ 2,4,4 ],  [ 2,4,5 ],
+                                                             [ 2,5,5 ],
+                                      [ 3,3,3 ], [ 3,3,4 ],  [ 3,3,5 ],
+                                                 [ 3,4,4 ],  [ 3,4,5 ],
+                                                             [ 3,5,5 ],
+                                                 [ 4,4,4 ],  [ 4,4,5 ],
+                                                             [ 4,5,5 ],
+                                                             [ 5,5,5 ]]
+
+c = GSL::Multiset::alloc(6, 3)
+c.init_first()
+i = 0
+status = 0
+while true
+  if i >= 56
+    status = 1;
+    break
+  end
+  for j in 0...3 do
+    if c.data[j] != c63[i][j] 
+      ret = 0
+    else
+      ret = 1
+    end
+    status |= ret
+  end
+  s1 = c.valid
+  GSL::Test::test(s1, "gsl_multiset_valid(#{i})")
+  i += 1
+  break if c.next != GSL::SUCCESS
+end

data/tests/odeiv.rb

@@ -0,0 +1,353 @@
+#!/usr/bin/env ruby
+# Ruby/GSL implementation of GSL "odeiv-initval/test.c"
+require("gsl")
+require("./gsl_test2.rb")
+include GSL::Test
+include Math
+
+rhs_linear = Proc.new { |t, y, f|
+  f[0] = 0.0
+  f[1] = y[0]
+  GSL::SUCCESS
+}
+
+jac_linear = Proc.new { |t, y, dfdy, dfdt|
+  dfdy.set(0, 0, 0.0)
+  dfdy.set(0, 1, 0.0)
+  dfdy.set(1, 0, 1.0)
+  dfdy.set(1, 1, 0.0)
+  dfdt[0] = 0.0
+  dfdt[1] = 0.0
+  GSL::SUCCESS
+}
+
+Rhs_func_lin = GSL::Odeiv::System.alloc(rhs_linear, jac_linear, 2)
+
+rhs_sin = Proc.new { |t, y, f|
+  f[0] = -y[1]
+  f[1] = y[0]
+  GSL::SUCCESS
+}
+
+jac_sin = Proc.new { |t, y, dfdy, dfdt|
+  dfdy.set(0, 0, 0.0)
+  dfdy.set(0, 1, -1.0)
+  dfdy.set(1, 0, 1.0)
+  dfdy.set(1, 1, 0.0)
+  dfdt[0] = 0.0
+  dfdt[1] = 0.0
+  GSL::SUCCESS
+}
+
+Rhs_func_sin = GSL::Odeiv::System.alloc(rhs_sin, jac_sin, 2)
+
+rhs_exp = Proc.new { |t, y, f|
+  f[0] = y[1]
+  f[1] = y[0]
+  GSL::SUCCESS
+}
+
+jac_exp = Proc.new { |t, y, dfdy, dfdt|
+  dfdy.set(0, 0, 0.0)
+  dfdy.set(0, 1, 1.0)
+  dfdy.set(1, 0, 1.0)
+  dfdy.set(1, 1, 0.0)
+  dfdt[0] = 0.0
+  dfdt[1] = 0.0
+  GSL::SUCCESS
+}
+
+Rhs_func_exp = GSL::Odeiv::System.alloc(rhs_exp, jac_exp, 2)
+
+rhs_stiff = Proc.new { |t, y, f|
+  f[0] = 998.0 * y[0] + 1998.0 * y[1]
+  f[1] = -999.0 * y[0] - 1999.0 * y[1]
+  GSL::SUCCESS
+}
+
+jac_stiff = Proc.new { |t, y, dfdy, dfdt|
+  dfdy.set(0, 0, 998.0);
+  dfdy.set(0, 1, 1998.0);
+  dfdy.set(1, 0, -999.0);
+  dfdy.set(1, 1, -1999.0);
+  dfdt[0] = 0.0;
+  dfdt[1] = 0.0;
+  GSL::SUCCESS;
+}
+
+Rhs_func_stiff = GSL::Odeiv::System.alloc(rhs_stiff, jac_stiff, 2)
+
+def test_stepper_linear(type, hstart, base_prec)
+  h = hstart*1.0
+  delmax = 0.0
+  count = 0
+  stepper = GSL::Odeiv::Step.alloc(type, 2)
+  y = GSL::Vector.alloc(1.0, 0.0)
+  yerr = GSL::Vector.alloc(2)
+  t = 0.0
+  s = 0
+  while t < 4.0
+    status = stepper.apply(t, h, y, yerr, Rhs_func_lin)
+    del = ((y[1] - (t + h))/y[1]).abs
+    delmax = MAX_DBL(del, delmax)
+    if del > (count + 1.0)*base_prec
+      printf("  LINEAR(%20.17g)  %20.17g  %20.17g  %8.4g\n", t + h, y[1], t + h, del);
+      s += 1
+    end
+    count += 1
+    t += h
+  end
+  GSL::Test::test(s, "#{stepper.name}, linear [0,4], max relative error = #{delmax}")
+end
+
+def test_stepper_sin(type, hstart, base_prec)
+  h = hstart*1.0
+  delmax = 0.0
+  count = 0
+  stepper = GSL::Odeiv::Step.alloc(type, 2)
+  y = GSL::Vector.alloc(1.0, 0.0)
+  yerr = GSL::Vector.alloc(2)
+  t = 0.0
+  s = 0
+  while t < M_PI
+    sin_th = sin(t + h)
+    status = stepper.apply(t, h, y, yerr, Rhs_func_sin)
+    del = ((y[1] - sin_th)/sin_th).abs
+    delmax = GSL::MAX_DBL(del, delmax)
+    if t < 0.5*M_PI
+      stat = (del > (count+1.0)*base_prec) ? 1 : 0
+    elsif t < 0.7*M_PI
+      stat = (del > 1.0e+04*base_prec) ? 1 : 0
+    elsif t < 0.9*M_PI
+      stat = (del > 1.0e+06*base_prec) ? 1 : 0
+    else
+      stat = (del > 1.0e+09*base_prec) ? 1 : 0
+    end
+    if stat != 0
+      printf("  SIN(%22.18g)  %22.18g  %22.18g  %10.6g\n", t + h, y[1], sin_th, del);
+    end
+    s += stat
+    count += 1
+    t += h
+  end
+  if delmax > 1.0e+09*base_prec
+    s += 1
+    printf("  SIN(0 .. M_PI)  delmax = %g\n", delmax)  
+  end
+  GSL::Test::test(s, "#{stepper.name}, sine [0,pi], max relative error = #{delmax}")
+
+  delmax = 0.0
+  while t < 3*M_PI
+    status = stepper.apply(t, h, y, yerr, Rhs_func_sin)
+    del = (y[1] - sin(t)).abs
+    delmax = GSL::MAX_DBL(del, delmax)
+    count += 1
+    t += h
+  end
+  if del > count * 2.0 * base_prec
+    s += 1
+    printf("  SIN(%22.18g)  %22.18g  %22.18g  %10.6g\n", t + h, y[1], sin(t), del)
+  end
+  test(s, "#{stepper.name}, sin [pi,3*pi], max absolute error = #{delmax}")
+end
+
+def test_stepper_exp(type, hstart, base_prec)
+  s = 0
+  y = GSL::Vector.alloc(1.0, 1.0)
+  yerr = GSL::Vector.alloc(2)
+  delmax = 0.0
+  count = 0
+  h = hstart*1.0
+  stepper = GSL::Odeiv::Step.alloc(type, 2)
+  t = 0.0
+  while t < 5.0
+    ex = exp(t + h)
+    status = stepper.apply(t, h, y, yerr, Rhs_func_exp)
+    del = ((y[1] - ex)/y[1]).abs
+    delmax = GSL::MAX_DBL(del, delmax)
+    if del > (count+1.0)*2.0*base_prec
+      printf("  EXP(%20.17g)  %20.17g  %20.17g  %8.4g\n", t + h, y[1], ex, del);
+      s += 1
+    end
+    count += 1
+    t += h
+  end
+  GSL::Test::test(s, "#{stepper.name}, exponential [0,5], max relative error = #{delmax}")
+end
+
+def test_stepper_stiff(type, hstart, base_prec)
+  h = hstart*1.0
+  s = 0
+  delmax = 0.0
+  count = 0
+  stepper = GSL::Odeiv::Step.alloc(type, 2)
+  y = GSL::Vector.alloc(1.0, 0.0)
+  yerr = GSL::Vector.alloc(2)
+  t = 0.0
+  while t < 5.0
+    status = stepper.apply(t, h, y, yerr, Rhs_func_stiff)
+    if t > 0.04
+      arg = t + h
+      e1 = exp(-arg)
+      e2 = exp(-1000.0*arg)
+      u = 2.0*e1 - e2
+      del = ((y[0] - u)/y[0]).abs
+      delmax = GSL::MAX_DBL(del, delmax)
+      if del > (count + 1.0)*100.0*base_prec
+        printf("  STIFF(%20.17g)  %20.17g  %20.17g  %8.4g\n", arg, y[0], u, del)
+        s += 1
+      end
+    end
+    count += 1
+    t += h
+  end
+  GSL::Test::test(s, "#{stepper.name}, stiff [0,5], max relative error = #{delmax}")
+end
+
+def test_stepper_err(type, hstart, base_prec)
+  h = hstart*1.0
+  y = GSL::Vector.alloc(1.0, 0.0)
+  yerr = GSL::Vector.alloc(2)
+  delmax = 0.0
+  errmax = 0.0
+  count = 0
+  s = 0
+
+  stepper = GSL::Odeiv::Step.alloc(type, 2)
+
+  t = 0.0
+  while t < M_PI
+    y1_t = y[1]
+    dy_exp = cos(t)*sin(h)-2*sin(t)*pow(sin(h/2),2.0);
+    status = stepper.apply(t, h, y, yerr, Rhs_func_sin)
+    dy_t = y[1] - y1_t;
+    del = (dy_t - dy_exp).abs
+    if t > 0.1 and t < 0.2
+      stat = (del > 10.0*yerr[1].abs + GSL::DBL_EPSILON*y[1].abs) ? 1 : 0
+      if stat != 0
+        delmax = del
+        errmax = yerr[1].abs
+        printf("SIN(%.18e) %.5e %.5e %e %e %e\n", t + h, y[1], dy_t, dy_exp, del, yerr[1]);
+
+        s += stat;
+        break;
+      end
+    end
+    count += 1
+    t += h
+  end
+  test(s, "#{stepper.name}, sine [0,pi], accurary of estimate error = #{delmax} vs #{errmax}")
+end
+
+def test_evolve_system_flat(step, sys, t0, t1, hstart, y, yfin, err_target, desc)
+  s = 0
+  h = hstart*1.0
+  t = t0*1.0
+  e = GSL::Odeiv::Evolve.alloc(sys.dimension)
+  while t < t1
+    t, h, status = e.apply(nil, step, sys, t, t1, h, y)
+  end
+  frac = ((y[1] - yfin[1])/yfin[1]).abs + ((y[0] - yfin[0])/yfin[0]).abs
+  if frac > 2.0*e.count*err_target
+    printf("FLAT t = %.5e  y0 = %g y1= %g\n", t, y[0], y[1]);
+    s += 1
+  end
+  GSL::Test::test(s, "#{step.name}, #{desc}, evolve, no control, max relative error = #{frac}")
+end
+
+def test_evolve_system(type, sys, t0, t1, hstart, y, yfin, err_target, desc)
+  s = 0
+  t = t0*1.0
+  h = hstart*1.0
+  step = GSL::Odeiv::Step.alloc(type, sys.dimension)
+  c = GSL::Odeiv::Control.standard_alloc(0.0, err_target, 1.0, 1.0)
+  e = GSL::Odeiv::Evolve.alloc(sys.dimension)
+  while t < t1
+    t, h, status = e.apply(c, step, sys, t, t1, h, y)
+  end
+  frac = ((y[1] - yfin[1])/yfin[1]).abs + ((y[0] - yfin[0])/yfin[0]).abs
+  if frac > 2.0*e.count*err_target
+    printf("SYS t = %.5e h = %g y0 = %g y1= %g\n", t, h, y[0], y[1]);
+    s += 1
+  end
+  GSL::Test::test(s, "#{step.name}, #{desc}, evolve, standard control, relative error = #{frac}")
+end
+
+def test_evolve_exp(type, hstart, err)
+  h = hstart*1.0
+  y = GSL::Vector.alloc(1.0, 1.0)
+  eee = exp(5.0)
+  yfin = GSL::Vector.alloc(eee, eee)
+  test_evolve_system(type, Rhs_func_exp, 0.0, 5.0, h, y, yfin, err, "exp [0,5]")
+end
+
+def test_evolve_sin(type, hstart, err)
+  h = hstart*1.0
+  y = GSL::Vector.alloc(1.0, 0.0)
+  yfin = GSL::Vector.alloc(cos(2.0), sin(2.0))
+  test_evolve_system(type, Rhs_func_sin, 0.0, 2.0, h, y, yfin, err, "sin [0,2]")
+end
+
+def test_evolve_stiff1(type, hstart, err)
+  h = hstart*1.0
+  y = GSL::Vector.alloc(1.0, 0.0)
+  arg = 1.0
+  e1 = exp(-arg)
+  e2 = exp(-1000.0*arg)
+  yfin = GSL::Vector.alloc(2.0*e1 - e2, -e1 + e2)
+  test_evolve_system(type, Rhs_func_stiff, 0.0, 1.0, h, y, yfin, err, "stiff [0,1]")
+end
+
+def test_evolve_stiff5(type, hstart, err)
+  h = hstart*1.0
+  y = GSL::Vector.alloc(1.0, 0.0)
+  arg = 5.0
+  e1 = exp(-arg)
+  e2 = exp(-1000.0*arg)
+  yfin = GSL::Vector.alloc(2.0*e1 - e2, -e1 + e2)
+less  test_evolve_system(type, Rhs_func_stiff, 0.0, 5.0, h, y, yfin, err, "stiff [0,5]")
+end
+
+ptypes = [
+  {"type" => "rk2",
+   "h" => 1e-3},
+  {"type" => "rk2imp",
+   "h" => 1e-3},
+  {"type" => "rk4",
+   "h" => 1e-3},
+  {"type" => "rk4imp",
+   "h" => 1e-3},
+  {"type" => "rkf45",
+   "h" => 1e-3},
+  {"type" => "rk8pd",
+   "h" => 1e-3},
+  {"type" => "rkck",
+   "h" => 1e-3},
+  {"type" => "bsimp",
+   "h" => 1e-3},
+  {"type" => "gear1",
+   "h" => 1e-3},
+#  {"type" => "gear2",
+#   "h" => 1e-3}
+]
+
+GSL::IEEE::env_setup()
+
+ptypes.each do |hash|
+  test_stepper_err(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON)
+end
+
+ptypes.each do |hash|
+#  test_stepper_linear(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON)
+#  test_stepper_sin(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON)
+  test_stepper_sin(hash["type"], hash["h"]/10, 1e-8)  
+#  test_stepper_exp(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON)
+#  test_stepper_stiff(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON)
+end
+
+ptypes.each do |hash|
+#  test_evolve_exp(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON)
+  test_evolve_sin(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON)
+#  test_evolve_stiff1(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON)
+#  test_evolve_stiff5(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON)
+end