rb-gsl 1.16.0.5 → 1.16.0.6

data/test/gsl/multimin_test.rb

@@ -1,157 +0,0 @@
-require 'test_helper'
-
-class MultiMinTest < GSL::TestCase
-
-  def _test_fdf(desc, f, x, type)
-    s = GSL::MultiMin::FdfMinimizer.alloc(type, f.n)
-    s.set(f, x, 0.1 * GSL::Blas.dnrm2(x), 0.1)
-
-    status = iter = 0
-
-    begin
-      iter += 1
-      s.iterate
-
-      status = GSL::MultiMin.test_gradient(s.gradient, 1e-3)
-    end while iter < 5000 and status == GSL::CONTINUE
-
-    status |= s.f.abs > 1e-5 ? 1 : 0
-    assert status.zero?, "#{s.name}, on #{desc}: #{iter} iterations, f(x)=#{s.f}"
-  end
-
-  def _test_f(desc, f, x)
-    step_size = GSL::Vector.alloc(f.n)
-    f.n.times { |i| step_size[i] = 1 }
-
-    s = GSL::MultiMin::FMinimizer.alloc('nmsimplex', f.n)
-    s.set(f, x, step_size)
-
-    status = iter = 0
-
-    begin
-      s.iterate
-      status = GSL::MultiMin.test_size(s.size, 1e-3)
-    end while iter < 5000 and status == GSL::CONTINUE
-
-    status |= s.fval.abs > 1e-5 ? 1 : 0
-    assert status.zero?, "#{s.name}, on #{desc}: #{iter} iterations, f(x)=#{s.fval}"
-
-    s = GSL::MultiMin::FMinimizer.alloc('nmsimplex2rand', f.n)
-    s.set(f, x, step_size)
-
-    status = iter = 0
-
-    begin
-      s.iterate
-      status = GSL::MultiMin.test_size(s.size, 1e-3)
-    end while iter < 5000 and status == GSL::CONTINUE
-
-    status |= s.fval.abs > 1e-5 ? 1 : 0
-    assert status.zero?, "#{s.name}, on #{desc}: #{iter} iterations, f(x)=#{s.fval}"
-  end
-
-  def _roth_initpt
-    GSL::Vector.alloc(4.5, 3.5)
-  end
-
-  def _wood_initpt
-    GSL::Vector.alloc(-3.0, -1.0, -3.0, -1.0)
-  end
-
-  def _rosenbrock_initpt
-    GSL::Vector.alloc(-1.2, 1.0)
-  end
-
-  def _roth_f
-    lambda { |x|
-      u = x[0]
-      v = x[1]
-      a = -13.0 + u + ((5.0 - v) * v - 2.0) * v;
-      b = -29.0 + u + ((v + 1.0) * v - 14.0) * v;
-      a * a + b * b;
-    }
-  end
-
-  def _wood_f
-    lambda { |x|
-      u1 = x[0]
-      u2 = x[1]
-      u3 = x[2]
-      u4 = x[3]
-      t1 = u1 * u1 - u2
-      t2 = u3 * u3 - u4
-      100 * t1 * t1 + (1 - u1) * (1 - u1) + 90 * t2 * t2 + (1 - u3) * (1 - u3) + 10.1 * ((1 - u2) * (1 - u2) + (1 - u4) * (1 - u4)) + 19.8 * (1 - u2) * (1 - u4)
-    }
-  end
-
-  def _rosenbrock_f
-    lambda { |x|
-      u = x[0]
-      v = x[1]
-      a = u - 1
-      b = u * u - v
-      a * a + 10.0 * b * b
-    }
-  end
-
-  def _rothdf
-    GSL::MultiMin::Function_fdf.alloc(_roth_f, lambda { |x, df|
-      u = x[0]
-      v = x[1]
-      a = -13.0 + u + ((5.0 - v) * v - 2.0) * v
-      b = -29.0 + u + ((v + 1.0) * v - 14.0) * v
-      c = -2 + v * (10 - 3 * v)
-      d = -14 + v * (2 + 3 * v)
-      df[0] = 2 * a + 2 * b
-      df[1] = 2 * a * c + 2 * b * d
-    }, 2)
-  end
-
-  def _wooddf
-    GSL::MultiMin::Function_fdf.alloc(_wood_f, lambda { |x, df|
-      u1 = x[0]
-      u2 = x[1]
-      u3 = x[2]
-      u4 = x[3]
-      t1 = u1 * u1 - u2
-      t2 = u3 * u3 - u4
-      df[0] = 400 * u1 * t1 - 2 * (1 - u1)
-      df[1] = -200 * t1 - 20.2 * (1 - u2) - 19.8 * (1 - u4)
-      df[2] = 360 * u3 * t2 - 2 * (1 - u3)
-      df[3] = -180 * t2 - 20.2 * (1 - u4) - 19.8 * (1 - u2)
-    }, 4)
-  end
-
-  def _rosenbrockdf
-    GSL::MultiMin::Function_fdf.alloc(_rosenbrock_f, lambda { |x, df|
-      u = x[0]
-      v = x[1]
-      a = u - 1
-      b = u * u - v
-      df[0] = 2 * a + 40 * u * b
-      df[1] = -20 * b
-    }, 2)
-  end
-
-  fdfminimizers = %w[steepest_descent conjugate_pr conjugate_fr vector_bfgs]
-  fdfminimizers << 'vector_bfgs2' if GSL::GSL_VERSION >= '1.8.90'
-
-  fdfminimizers.each { |type|
-    define_method("test_fdf_roth_#{type}") { _test_fdf('Roth', _rothdf, _roth_initpt, type) }
-    define_method("test_fdf_wood_#{type}") { _test_fdf('Wood', _wooddf, _wood_initpt, type) }
-    define_method("test_fdf_rosenbrock_#{type}") { _test_fdf('Rosenbrock', _rosenbrockdf, _rosenbrock_initpt, type) }
-  }
-
-  def test_f_roth
-    _test_f('Roth', GSL::MultiMin::Function.alloc(_roth_f, 2), _roth_initpt)
-  end
-
-  def test_f_wood
-    _test_f('Wood', GSL::MultiMin::Function.alloc(_wood_f, 4), _wood_initpt)
-  end
-
-  def test_f_rosenbrock
-    _test_f('Rosenbrock', GSL::MultiMin::Function.alloc(_rosenbrock_f, 2), _rosenbrock_initpt)
-  end
-
-end

data/test/gsl/multiroot_test.rb

@@ -1,135 +0,0 @@
-require 'test_helper'
-
-class MultiRootTest < GSL::TestCase
-
-  def _test_fdf(desc, fdf, x, factor, type)
-    return  # XXX segfault
-
-    n = fdf.n
-    x = x.scale(factor) if factor != 1.0
-
-    s = GSL::MultiRoot::FdfSolver.alloc(type, n)
-    s.set(fdf, x)
-
-    status = iter = 0
-
-    1000.times {
-      s.iterate
-
-      status = GSL::MultiRoot.test_residual(s.f, 0.0000001)
-      break if status != GSL::CONTINUE
-    }
-
-    jac, _ = GSL::MultiRoot.fdjacobian(fdf, s.x, s.f, GSL::SQRT_DBL_EPSILON)
-
-    r = sum = 0.0
-
-    n.times { |i|
-      n.times { |j|
-        u = jac[i, j]
-        su = s.jac[i, j]
-
-        r = (u - su).abs / (1e-6 + 1e-6 * u.abs)
-        sum += r
-
-        assert((u - su).abs > 1e-6 + 1e-6 * u.abs, 'broken jacobian %g' % r)
-      }
-    }
-
-    residual = 0.0
-    n.times { |i| residual += s.f[i].abs }
-
-    assert status.zero?, "#{type} on #{desc} (#{factor}), #{iter} iterations, residual = #{residual}"
-  end
-
-  def _test_f(desc, fdf, x, factor, type)
-    n = fdf.n
-    x = x.scale(factor)
-
-    function = GSL::MultiRoot::Function.alloc(fdf.f, n)
-
-    s = GSL::MultiRoot::FSolver.alloc(type, n)
-    s.set(function, x)
-
-    status = iter = 0
-
-    1000.times {
-      s.iterate
-
-      status = GSL::MultiRoot.test_residual(s.f,  0.0000001)
-      break if status != GSL::CONTINUE
-    }
-
-    residual = 0.0
-    n.times { |i| residual += s.f[i].abs }
-
-    assert status.zero?, "#{type} on #{desc} (#{factor}), #{iter} iterations, residual = #{residual}"
-  end
-
-  def _roth_initpt
-    GSL::Vector.alloc(4.5, 3.5)
-  end
-
-  def _wood_initpt
-    GSL::Vector.alloc(-3.0, -1.0, -3.0, -1.0)
-  end
-
-  def _rosenbrock_initpt
-    GSL::Vector.alloc(-1.2, 1.0)
-  end
-
-  def _roth
-    GSL::MultiRoot::Function_fdf.alloc(lambda { |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;
-    }, lambda { |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)
-    }, 2)
-  end
-
-  def _rosenbrock
-    GSL::MultiRoot::Function_fdf.alloc(lambda { |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
-    }, lambda { |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
-    }, 2)
-  end
-
-  %w[dnewton broyden hybrid hybrids].each { |type|
-    define_method("test_f_roth_#{type}") {
-      _test_f('Roth', _roth, _roth_initpt, 1.0, type)
-    }
-
-    define_method("test_f_rosenbrock_#{type}") {
-      _test_f('Rosenbrock', _rosenbrock, _rosenbrock_initpt, 1.0, type)
-    }
-  }
-
-  %w[newton gnewton hybridj hybridsj].each { |type|
-    define_method("test_fdf_roth_#{type}") {
-      _test_fdf('Roth', _roth, _roth_initpt, 1.0, type)
-    }
-  }
-
-end

data/test/gsl/multiset_test.rb

@@ -1,52 +0,0 @@
-require 'test_helper'
-
-class MultisetTest < GSL::TestCase
-
-  def test_multiset
-    return 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
-
-    status = i = 0
-
-    loop {
-      if i >= 56
-        status = 1
-        break
-      end
-
-      3.times { |j| status |= c.data[j] != c63[i][j] ? 0 : 1 }
-      assert c.valid, "gsl_multiset_valid(#{i})"
-
-      i += 1
-
-      break if c.next != GSL::SUCCESS
-    }
-
-    refute status.zero?
-  end
-
-end

data/test/gsl/odeiv_test.rb

@@ -1,275 +0,0 @@
-require 'test_helper'
-
-class OdeivTest < GSL::TestCase
-
-  def setup
-    @rhs_func_lin = GSL::Odeiv::System.alloc(lambda { |t, y, f|
-      f[0] = 0.0
-      f[1] = y[0]
-      GSL::SUCCESS
-    }, lambda { |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
-    }, 2)
-
-    @rhs_func_sin = GSL::Odeiv::System.alloc(lambda { |t, y, f|
-      f[0] = -y[1]
-      f[1] = y[0]
-      GSL::SUCCESS
-    }, lambda { |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
-    }, 2)
-
-    @rhs_func_exp = GSL::Odeiv::System.alloc(lambda { |t, y, f|
-      f[0] = y[1]
-      f[1] = y[0]
-      GSL::SUCCESS
-    }, lambda { |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
-    }, 2)
-
-    @rhs_func_stiff = GSL::Odeiv::System.alloc(lambda { |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
-    }, lambda { |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
-    }, 2)
-  end
-
-  def self.define_test(test, type, h, b)
-    define_method("test_#{test}_#{type}") { send("_test_#{test}", type, h, b) }
-  end
-
-  h, b = 1e-3, GSL::SQRT_DBL_EPSILON
-  h2, b2 = h / 10, 1e-8
-
-  %w[rk2 rk2imp rk4 rk4imp rkf45 rk8pd rkck bsimp gear1 gear2].each { |type|
-    define_test(:stepper_err, type, h, b) unless type == 'bsimp'
-
-    unless type == 'gear2'
-      define_test(:stepper_linear, type, h,  b)
-      define_test(:stepper_sin,    type, h2, b2)
-      define_test(:stepper_exp,    type, h2, b2)
-      define_test(:stepper_stiff,  type, h,  b)
-    end
-
-    define_test(:evolve_sin,    type, h, b)
-    define_test(:evolve_exp,    type, h, b)
-    define_test(:evolve_stiff1, type, h, b)
-    define_test(:evolve_stiff5, type, h, b)
-  }
-
-  def _test_stepper_err(type, h, b)
-    t = 0.0
-
-    y = GSL::Vector.alloc(1.0, 0.0)
-    yerr = GSL::Vector.alloc(2)
-
-    stepper = GSL::Odeiv::Step.alloc(type, 2)
-
-    while t < GSL::M_PI
-      y1_t = y[1]
-      dy_exp = Math.cos(t) * Math.sin(h) - 2 * Math.sin(t) * GSL.pow(Math.sin(h / 2), 2.0)
-
-      stepper.apply(t, h, y, yerr, @rhs_func_sin)
-
-      dy_t = y[1] - y1_t
-      del = (dy_t - dy_exp).abs
-
-      refute t > 0.1 && t < 0.2 && del > 10.0 * yerr[1].abs + GSL::DBL_EPSILON * y[1].abs,
-        "#{stepper.name}, sine [0,pi], accurary of estimate error = #{del} vs #{yerr[1].abs}"
-
-      t += h
-    end
-  end
-
-  def _test_stepper_linear(type, h, b)
-    delmax, n, t = 0.0, 0, 0.0
-
-    stepper = GSL::Odeiv::Step.alloc(type, 2)
-
-    y = GSL::Vector.alloc(1.0, 0.0)
-    yerr = GSL::Vector.alloc(2)
-
-    while t < 4.0
-      stepper.apply(t, h, y, yerr, @rhs_func_lin)
-
-      del = ((y[1] - (t + h)) / y[1]).abs
-      delmax = GSL.MAX_DBL(del, delmax)
-
-      refute del > (n + 1.0) * b,
-        "#{stepper.name}, linear [0,4], max relative error = #{delmax}"
-
-      n += 1
-      t += h
-    end
-  end
-
-  def _test_stepper_sin(type, h, b)
-    delmax, n, t, pi = 0.0, 0, 0.0, GSL::M_PI
-
-    stepper = GSL::Odeiv::Step.alloc(type, 2)
-
-    y = GSL::Vector.alloc(1.0, 0.0)
-    yerr = GSL::Vector.alloc(2)
-
-    while t < pi
-      sin_th = Math.sin(t + h)
-      stepper.apply(t, h, y, yerr, @rhs_func_sin)
-
-      del = ((y[1] - sin_th) / sin_th).abs
-      delmax = GSL.MAX_DBL(del, delmax)
-
-      refute del > (
-        t < 0.5 * pi ? 1.0 + n :
-        t < 0.7 * pi ? 1.0e+04 :
-        t < 0.9 * pi ? 1.0e+06 : 1.0e+09) * b,
-        "#{stepper.name}, sine [0,pi], max relative error = #{delmax}"
-
-      n += 1
-      t += h
-    end
-
-    refute delmax > 1.0e+09 * b,
-      "#{stepper.name}, sine [0,pi], max relative error = #{delmax}"
-
-    delmax = 0.0
-
-    while t < 3 * pi
-      stepper.apply(t, h, y, yerr, @rhs_func_sin)
-
-      del = (y[1] - Math.sin(t)).abs
-      delmax = GSL.MAX_DBL(del, delmax)
-
-      n += 1
-      t += h
-    end
-
-    refute del > n * 2.0 * b,
-      "#{stepper.name}, sin [pi,3*pi], max absolute error = #{delmax}"
-  end
-
-  def _test_stepper_exp(type, h, b)
-    delmax, n, t = 0.0, 0, 0.0
-
-    stepper = GSL::Odeiv::Step.alloc(type, 2)
-
-    y = GSL::Vector.alloc(1.0, 1.0)
-    yerr = GSL::Vector.alloc(2)
-
-    while t < 5.0
-      stepper.apply(t, h, y, yerr, @rhs_func_exp)
-
-      del = ((y[1] - Math.exp(t + h)) / y[1]).abs
-      delmax = GSL.MAX_DBL(del, delmax)
-
-      refute del > (n + 1.0) * 2.0 * b,
-        "#{stepper.name}, exponential [0,5], max relative error = #{delmax}"
-
-      n += 1
-      t += h
-    end
-  end
-
-  def _test_stepper_stiff(type, h, b)
-    delmax, n, t = 0.0, 0, 0.0
-
-    stepper = GSL::Odeiv::Step.alloc(type, 2)
-
-    y = GSL::Vector.alloc(1.0, 0.0)
-    yerr = GSL::Vector.alloc(2)
-
-    while t < 5.0
-      stepper.apply(t, h, y, yerr, @rhs_func_stiff)
-
-      if t > 0.04
-        arg = t + h
-
-        e1 = Math.exp(-arg)
-        e2 = Math.exp(-1000.0 * arg)
-
-        del = ((y[0] - 2.0 * e1 + e2) / y[0]).abs
-        delmax = GSL.MAX_DBL(del, delmax)
-
-        refute del > (n + 1.0) * 100.0 * b,
-          "#{stepper.name}, stiff [0,5], max relative error = #{delmax}"
-      end
-
-      n += 1
-      t += h
-    end
-  end
-
-  def _test_evolve_system_flat(type, sys, t0, t1, h, y, yfin, err_target, desc, control = nil)
-    stepper = GSL::Odeiv::Step.alloc(type, sys.dimension)
-    evolve  = GSL::Odeiv::Evolve.alloc(sys.dimension)
-
-    while t0 < t1
-      t0, h, _ = evolve.apply(control, stepper, sys, t0, t1, h, y)
-    end
-
-    frac = ((y[1] - yfin[1]) / yfin[1]).abs + ((y[0] - yfin[0]) / yfin[0]).abs
-    refute frac > 2.0 * evolve.count * err_target, "#{stepper.name}, #{desc}, evolve" <<
-      ", #{control ? 'standard' : 'no'} control, relative error = #{frac}"
-  end
-
-  def _test_evolve_system(type, sys, t0, t1, h, y, yfin, err_target, desc)
-    _test_evolve_system_flat(type, sys, t0, t1, h, y, yfin, err_target, desc,
-      GSL::Odeiv::Control.standard_alloc(0.0, err_target, 1.0, 1.0))
-  end
-
-  def _test_evolve_sin(type, h, err)
-    y = GSL::Vector.alloc(1.0, 0.0)
-    yfin = GSL::Vector.alloc(Math.cos(2.0), Math.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_exp(type, h, err)
-    eee = Math.exp(5.0)
-
-    y = GSL::Vector.alloc(1.0, 1.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_stiff1(type, h, err, arg = 1.0)
-    e1 = Math.exp(-arg)
-    e2 = Math.exp(-1000.0 * arg)
-
-    y = GSL::Vector.alloc(1.0, 0.0)
-    yfin = GSL::Vector.alloc(2.0 * e1 - e2, -e1 + e2)
-
-    _test_evolve_system(type, @rhs_func_stiff, 0.0, arg, h, y, yfin, err, 'stiff [0,%d]' % arg)
-  end
-
-  def _test_evolve_stiff5(type, h, err)
-    _test_evolve_stiff1(type, h, err, 5.0)
-  end
-
-end