rb-gsl 1.15.3.1 → 1.15.3.2

data/tests/multiroot.rb

@@ -1,131 +0,0 @@
-#!/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

@@ -1,52 +0,0 @@
-#!/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/narray/blas_dnrm2.rb

@@ -1,20 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require 'narray'
-require 'gsl'
-require '../gsl_test.rb'
-include GSL::Test
-
-dbleps = 1e-6
-expected = Math.sqrt((0..4).inject {|m,x| m+=x*x})
-
-v = GSL::Vector.indgen(5)
-v_dnrm2 = GSL::Blas.dnrm2(v)
-GSL::Test.test_rel(v_dnrm2, expected, dbleps, "GSL::Blas.dnrm2(GSL::Vector)")
-
-na = NArray.float(5).indgen!
-na_dnrm2 = GSL::Blas.dnrm2(na)
-GSL::Test.test_rel(na_dnrm2, expected, dbleps, "GSL::Blas.dnrm2(NArray)")
-
-GSL::Test.test_rel(na_dnrm2, v_dnrm2, 0, "GSL::Blas.dnrm2(NArray) == GSL::Blas.dnrm2(GSL::Vector)")

data/tests/odeiv.rb

@@ -1,353 +0,0 @@
-#!/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